[Mesa-dev] [PATCH V4 6/6] i965/fs: add support for ir_*_interpolate_at_* expressions

[Chris Forbes]

SIMD8-only for now.

Signed-off-by: Chris Forbes <chrisf at ijw.co.nz>
---
 src/mesa/drivers/dri/i965/brw_fs.h           |   1 +
 src/mesa/drivers/dri/i965/brw_fs_visitor.cpp | 135 ++++++++++++++++++++++++++-
 2 files changed, 134 insertions(+), 2 deletions(-)

diff --git a/src/mesa/drivers/dri/i965/brw_fs.h b/src/mesa/drivers/dri/i965/brw_fs.h
index 48f1069..0bb328a 100644
--- a/src/mesa/drivers/dri/i965/brw_fs.h
+++ b/src/mesa/drivers/dri/i965/brw_fs.h
@@ -390,6 +390,7 @@ public:
                     const fs_reg &src0, const fs_reg &src1);
    bool try_emit_saturate(ir_expression *ir);
    bool try_emit_mad(ir_expression *ir);
+   void emit_interpolate_expression(ir_expression *ir);
    void try_replace_with_sel();
    bool opt_peephole_sel();
    bool opt_peephole_predicated_break();
diff --git a/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp b/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp
index 8e8affa..2f37986 100644
--- a/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp
@@ -344,6 +344,118 @@ fs_visitor::try_emit_mad(ir_expression *ir)
    return true;
 }
 
+static int
+pack_pixel_offset(float x)
+{
+   int n = MIN2((int)(x * 16), 7);
+   return n & 0xf;
+}
+
+void
+fs_visitor::emit_interpolate_expression(ir_expression *ir)
+{
+   /* in SIMD16 mode, the pixel interpolator returns coords interleaved
+    * 8 channels at a time, same as the barycentric coords presented in
+    * the FS payload. this requires a bit of extra work to support.
+    */
+   no16("interpolate_at_* not yet supported in SIMD16 mode.");
+
+   ir_dereference * deref = ir->operands[0]->as_dereference();
+   ir_swizzle * swiz = NULL;
+   if (!deref) {
+      /* the api does not allow a swizzle here, but the varying packing code
+       * may have pushed one into here.
+       */
+      swiz = ir->operands[0]->as_swizzle();
+      assert(swiz);
+      deref = swiz->val->as_dereference();
+   }
+   assert(deref);
+   ir_variable * var = deref->variable_referenced();
+   assert(var);
+
+   /* 1. collect interpolation factors */
+
+   fs_reg dst_x = fs_reg(this, glsl_type::get_instance(ir->type->base_type, 2, 1));
+   fs_reg dst_y = dst_x;
+   dst_y.reg_offset++;
+
+   /* for most messages, we need one reg of ignored data; the hardware requires mlen==1
+    * even when there is no payload. in the per-slot offset case, we'll replace this with
+    * the proper source data. */
+   fs_reg src = fs_reg(this, glsl_type::float_type);
+   int mlen = 1;     /* one reg unless overriden */
+   int msg_type = 0; /* message type to be packed into the descriptor */
+   int imm_data = 0; /* data to be packed into the message descriptor */
+
+   switch (ir->operation) {
+   case ir_unop_interpolate_at_centroid:
+      {
+         msg_type = GEN7_PIXEL_INTERPOLATOR_LOC_CENTROID;
+      } break;
+
+   case ir_binop_interpolate_at_sample:
+      {
+         ir_constant *sample_num = ir->operands[1]->as_constant();
+         assert(sample_num || !"nonconstant sample number should have been lowered.");
+
+         msg_type = GEN7_PIXEL_INTERPOLATOR_LOC_SAMPLE;
+         imm_data = sample_num->value.i[0] << 4;
+      } break;
+
+   case ir_binop_interpolate_at_offset:
+      {
+         ir_constant *const_offset = ir->operands[1]->as_constant();
+         if (const_offset) {
+            msg_type = GEN7_PIXEL_INTERPOLATOR_LOC_SHARED_OFFSET;
+            imm_data = pack_pixel_offset(const_offset->value.f[0]) |
+                       (pack_pixel_offset(const_offset->value.f[1]) << 4);
+         } else {
+            /* pack the operands: hw wants offsets as 4 bit signed ints */
+            ir->operands[1]->accept(this);
+            src = fs_reg(this, glsl_type::ivec2_type);
+            fs_reg src2 = src;
+            for (int i = 0; i < 2; i++) {
+               fs_reg temp = fs_reg(this, glsl_type::float_type);
+               emit(MUL(temp, this->result, fs_reg(16.0f)));
+               emit(MOV(src2, temp));  /* float to int */
+               fs_inst *inst = emit(BRW_OPCODE_SEL, src2, src2, fs_reg(7));
+               inst->conditional_mod = BRW_CONDITIONAL_L; /* min(src2, 7) */
+
+               src2.reg_offset++;
+               this->result.reg_offset++;
+            }
+
+            mlen = 2 * dispatch_width / 8;
+            msg_type = GEN7_PIXEL_INTERPOLATOR_LOC_PER_SLOT_OFFSET;
+         }
+      } break;
+
+   default:
+      unreachable("not reached");
+   }
+
+   fs_inst *inst = emit(FS_OPCODE_PIXEL_INTERPOLATOR_QUERY, dst_x, src);
+   inst->mlen = mlen;
+   inst->regs_written = 2 * dispatch_width / 8; /* 2 floats per slot returned */
+   inst->pi_noperspective = var->determine_interpolation_mode(key->flat_shade) == INTERP_QUALIFIER_NOPERSPECTIVE;
+   inst->pi_msg_type = msg_type;
+   inst->pi_msg_data = imm_data;
+
+   /* 2. emit linterp */
+
+   fs_reg res(this, ir->type);
+   this->result = res;
+
+   for (int i = 0; i < ir->type->vector_elements; i++) {
+      int ch = swiz ? ((*(int *)&swiz->mask) >> 2*i) & 3 : i;
+      emit(FS_OPCODE_LINTERP, res,
+           dst_x, dst_y,
+           fs_reg(interp_reg(var->data.location, ch)));
+      res.reg_offset++;
+   }
+}
+
 void
 fs_visitor::visit(ir_expression *ir)
 {
@@ -355,9 +467,22 @@ fs_visitor::visit(ir_expression *ir)
 
    if (try_emit_saturate(ir))
       return;
-   if (ir->operation == ir_binop_add) {
+
+   /* Deal with the real oddball stuff first */
+   switch (ir->operation) {
+   case ir_binop_add:
       if (try_emit_mad(ir))
-	 return;
+         return;
+      break;
+
+   case ir_unop_interpolate_at_centroid:
+   case ir_binop_interpolate_at_offset:
+   case ir_binop_interpolate_at_sample:
+      emit_interpolate_expression(ir);
+      return;
+
+   default:
+      break;
    }
 
    for (operand = 0; operand < ir->get_num_operands(); operand++) {
@@ -815,6 +940,12 @@ fs_visitor::visit(ir_expression *ir)
       inst = emit(BRW_OPCODE_SEL, this->result, op[1], op[2]);
       inst->predicate = BRW_PREDICATE_NORMAL;
       break;
+
+   case ir_unop_interpolate_at_centroid:
+   case ir_binop_interpolate_at_offset:
+   case ir_binop_interpolate_at_sample:
+      assert(!"not reached; already handled above");
+      break;
    }
 }
 
-- 
2.0.1