自学教程：C++ ureg_DECL_temporary函数代码示例

voidvl_idct_stage2_frag_shader(struct vl_idct *idct, struct ureg_program *shader,                           unsigned first_input, struct ureg_dst fragment){    struct ureg_src l_addr[2], r_addr[2];    struct ureg_dst l[2], r[2];    --first_input;    l_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_L_ADDR0, TGSI_INTERPOLATE_LINEAR);    l_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_L_ADDR1, TGSI_INTERPOLATE_LINEAR);    r_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_R_ADDR0, TGSI_INTERPOLATE_LINEAR);    r_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_R_ADDR1, TGSI_INTERPOLATE_LINEAR);    l[0] = ureg_DECL_temporary(shader);    l[1] = ureg_DECL_temporary(shader);    r[0] = ureg_DECL_temporary(shader);    r[1] = ureg_DECL_temporary(shader);    fetch_four(shader, l, l_addr, ureg_DECL_sampler(shader, 1), false);    fetch_four(shader, r, r_addr, ureg_DECL_sampler(shader, 0), true);    matrix_mul(shader, fragment, l, r);    ureg_release_temporary(shader, l[0]);    ureg_release_temporary(shader, l[1]);    ureg_release_temporary(shader, r[0]);    ureg_release_temporary(shader, r[1]);}

void *util_make_fs_msaa_resolve(struct pipe_context *pipe,                          enum tgsi_texture_type tgsi_tex, unsigned nr_samples,                          enum tgsi_return_type stype){   struct ureg_program *ureg;   struct ureg_src sampler, coord;   struct ureg_dst out, tmp_sum, tmp_coord, tmp;   unsigned i;   ureg = ureg_create(PIPE_SHADER_FRAGMENT);   if (!ureg)      return NULL;   /* Declarations. */   sampler = ureg_DECL_sampler(ureg, 0);   ureg_DECL_sampler_view(ureg, 0, tgsi_tex, stype, stype, stype, stype);   coord = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_GENERIC, 0,                              TGSI_INTERPOLATE_LINEAR);   out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);   tmp_sum = ureg_DECL_temporary(ureg);   tmp_coord = ureg_DECL_temporary(ureg);   tmp = ureg_DECL_temporary(ureg);   /* Instructions. */   ureg_MOV(ureg, tmp_sum, ureg_imm1f(ureg, 0));   ureg_F2U(ureg, tmp_coord, coord);   for (i = 0; i < nr_samples; i++) {      /* Read one sample. */      ureg_MOV(ureg, ureg_writemask(tmp_coord, TGSI_WRITEMASK_W),               ureg_imm1u(ureg, i));      ureg_TXF(ureg, tmp, tgsi_tex, ureg_src(tmp_coord), sampler);      if (stype == TGSI_RETURN_TYPE_UINT)         ureg_U2F(ureg, tmp, ureg_src(tmp));      else if (stype == TGSI_RETURN_TYPE_SINT)         ureg_I2F(ureg, tmp, ureg_src(tmp));      /* Add it to the sum.*/      ureg_ADD(ureg, tmp_sum, ureg_src(tmp_sum), ureg_src(tmp));   }   /* Calculate the average and return. */   ureg_MUL(ureg, tmp_sum, ureg_src(tmp_sum),            ureg_imm1f(ureg, 1.0 / nr_samples));   if (stype == TGSI_RETURN_TYPE_UINT)      ureg_F2U(ureg, out, ureg_src(tmp_sum));   else if (stype == TGSI_RETURN_TYPE_SINT)      ureg_F2I(ureg, out, ureg_src(tmp_sum));   else      ureg_MOV(ureg, out, ureg_src(tmp_sum));   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

static INLINE voidxrender_tex(struct ureg_program *ureg,	    struct ureg_dst dst,	    struct ureg_src coords,	    struct ureg_src sampler,	    struct ureg_src imm0,	    boolean repeat_none, boolean swizzle, boolean set_alpha){    if (repeat_none) {	struct ureg_dst tmp0 = ureg_DECL_temporary(ureg);	struct ureg_dst tmp1 = ureg_DECL_temporary(ureg);	ureg_SGT(ureg, tmp1, ureg_swizzle(coords,					  TGSI_SWIZZLE_X,					  TGSI_SWIZZLE_Y,					  TGSI_SWIZZLE_X,					  TGSI_SWIZZLE_Y), ureg_scalar(imm0,								       TGSI_SWIZZLE_X));	ureg_SLT(ureg, tmp0,		 ureg_swizzle(coords, TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,			      TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y), ureg_scalar(imm0,									   TGSI_SWIZZLE_W));	ureg_MIN(ureg, tmp0, ureg_src(tmp0), ureg_src(tmp1));	ureg_MIN(ureg, tmp0, ureg_scalar(ureg_src(tmp0), TGSI_SWIZZLE_X),		 ureg_scalar(ureg_src(tmp0), TGSI_SWIZZLE_Y));	ureg_TEX(ureg, tmp1, TGSI_TEXTURE_2D, coords, sampler);	if (swizzle)	    ureg_MOV(ureg, tmp1, ureg_swizzle(ureg_src(tmp1),					      TGSI_SWIZZLE_Z,					      TGSI_SWIZZLE_Y, TGSI_SWIZZLE_X,					      TGSI_SWIZZLE_W));	if (set_alpha)	    ureg_MOV(ureg,		     ureg_writemask(tmp1, TGSI_WRITEMASK_W),		     ureg_scalar(imm0, TGSI_SWIZZLE_W));	ureg_MUL(ureg, dst, ureg_src(tmp1), ureg_src(tmp0));	ureg_release_temporary(ureg, tmp0);	ureg_release_temporary(ureg, tmp1);    } else {	if (swizzle) {	    struct ureg_dst tmp = ureg_DECL_temporary(ureg);	    ureg_TEX(ureg, tmp, TGSI_TEXTURE_2D, coords, sampler);	    ureg_MOV(ureg, dst, ureg_swizzle(ureg_src(tmp),					     TGSI_SWIZZLE_Z,					     TGSI_SWIZZLE_Y, TGSI_SWIZZLE_X,					     TGSI_SWIZZLE_W));	    ureg_release_temporary(ureg, tmp);	} else {	    ureg_TEX(ureg, dst, TGSI_TEXTURE_2D, coords, sampler);	}	if (set_alpha)	    ureg_MOV(ureg,		     ureg_writemask(dst, TGSI_WRITEMASK_W),		     ureg_scalar(imm0, TGSI_SWIZZLE_W));    }}

static void *create_yuv_shader(struct pipe_context *pipe, struct ureg_program *ureg){    struct ureg_src y_sampler, u_sampler, v_sampler;    struct ureg_src pos;    struct ureg_src matrow0, matrow1, matrow2;    struct ureg_dst y, u, v, rgb;    struct ureg_dst out = ureg_DECL_output(ureg,					   TGSI_SEMANTIC_COLOR,					   0);    pos = ureg_DECL_fs_input(ureg,			     TGSI_SEMANTIC_GENERIC, 0,			     TGSI_INTERPOLATE_PERSPECTIVE);    rgb = ureg_DECL_temporary(ureg);    y = ureg_DECL_temporary(ureg);    u = ureg_DECL_temporary(ureg);    v = ureg_DECL_temporary(ureg);    y_sampler = ureg_DECL_sampler(ureg, 0);    u_sampler = ureg_DECL_sampler(ureg, 1);    v_sampler = ureg_DECL_sampler(ureg, 2);    matrow0 = ureg_DECL_constant(ureg, 0);    matrow1 = ureg_DECL_constant(ureg, 1);    matrow2 = ureg_DECL_constant(ureg, 2);    ureg_TEX(ureg, y, TGSI_TEXTURE_2D, pos, y_sampler);    ureg_TEX(ureg, u, TGSI_TEXTURE_2D, pos, u_sampler);    ureg_TEX(ureg, v, TGSI_TEXTURE_2D, pos, v_sampler);    ureg_SUB(ureg, u, ureg_src(u), ureg_scalar(matrow0, TGSI_SWIZZLE_W));    ureg_SUB(ureg, v, ureg_src(v), ureg_scalar(matrow0, TGSI_SWIZZLE_W));    ureg_MUL(ureg, rgb, ureg_scalar(ureg_src(y), TGSI_SWIZZLE_X), matrow0);    ureg_MAD(ureg, rgb,	     ureg_scalar(ureg_src(u), TGSI_SWIZZLE_X), matrow1, ureg_src(rgb));    ureg_MAD(ureg, rgb,	     ureg_scalar(ureg_src(v), TGSI_SWIZZLE_X), matrow2, ureg_src(rgb));    /* rgb.a = 1; */    ureg_MOV(ureg, ureg_writemask(rgb, TGSI_WRITEMASK_W),	     ureg_scalar(matrow0, TGSI_SWIZZLE_X));    ureg_MOV(ureg, out, ureg_src(rgb));    ureg_release_temporary(ureg, rgb);    ureg_release_temporary(ureg, y);    ureg_release_temporary(ureg, u);    ureg_release_temporary(ureg, v);    ureg_END(ureg);    return ureg_create_shader_and_destroy(ureg, pipe);}

static void *create_frag_shader(struct vl_matrix_filter *filter, unsigned num_offsets,                   struct vertex2f *offsets, const float *matrix_values){   struct ureg_program *shader;   struct ureg_src i_vtex;   struct ureg_src sampler;   struct ureg_dst tmp;   struct ureg_dst t_sum;   struct ureg_dst o_fragment;   unsigned i;   shader = ureg_create(PIPE_SHADER_FRAGMENT);   if (!shader) {      return NULL;   }   i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 0);   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT);   tmp = ureg_DECL_temporary(shader);   t_sum = ureg_DECL_temporary(shader);   o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   ureg_MOV(shader, t_sum, ureg_imm1f(shader, 0.0f));   for (i = 0; i < num_offsets; ++i) {      if (matrix_values[i] == 0.0f)         continue;      if (!is_vec_zero(offsets[i])) {         ureg_ADD(shader, ureg_writemask(tmp, TGSI_WRITEMASK_XY),                  i_vtex, ureg_imm2f(shader, offsets[i].x, offsets[i].y));         ureg_MOV(shader, ureg_writemask(tmp, TGSI_WRITEMASK_ZW),                  ureg_imm1f(shader, 0.0f));         ureg_TEX(shader, tmp, TGSI_TEXTURE_2D, ureg_src(tmp), sampler);      } else {         ureg_TEX(shader, tmp, TGSI_TEXTURE_2D, i_vtex, sampler);      }      ureg_MAD(shader, t_sum, ureg_src(tmp), ureg_imm1f(shader, matrix_values[i]),               ureg_src(t_sum));   }   ureg_MOV(shader, o_fragment, ureg_src(t_sum));   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, filter->pipe);}

static void *create_copy_frag_shader(struct vl_deint_filter *filter, unsigned field){   struct ureg_program *shader;   struct ureg_src i_vtex;   struct ureg_src sampler;   struct ureg_dst o_fragment;   struct ureg_dst t_tex;   shader = ureg_create(PIPE_SHADER_FRAGMENT);   if (!shader) {      return NULL;   }   t_tex = ureg_DECL_temporary(shader);   i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 2);   o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   ureg_MOV(shader, t_tex, i_vtex);   if (field) {      ureg_MOV(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_ZW),               ureg_imm4f(shader, 0, 0, 1.0f, 0));   } else {      ureg_MOV(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_ZW),               ureg_imm1f(shader, 0));   }   ureg_TEX(shader, o_fragment, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_tex), sampler);   ureg_release_temporary(shader, t_tex);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, filter->pipe);}

static struct ureg_dstget_temp(struct st_translate *t, unsigned index){   if (ureg_dst_is_undef(t->temps[index]))      t->temps[index] = ureg_DECL_temporary(t->ureg);   return t->temps[index];}

/** * Create a simple vertex shader that passes through position and the given * attribute. */static void *create_passthrough_vs(struct pipe_context *pipe, int semantic_name){   struct ureg_program *ureg;   struct ureg_src src[2], constants[3];   struct ureg_dst dst[2], tmp;   int i;   ureg = ureg_create(TGSI_PROCESSOR_VERTEX);   if (!ureg)      return NULL;   /* position is in user coordinates */   src[0] = ureg_DECL_vs_input(ureg, 0);   dst[0] = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);   tmp = ureg_DECL_temporary(ureg);   for (i = 0; i < Elements(constants); i++)      constants[i] = ureg_DECL_constant(ureg, i);   /* transform to clipped coordinates */   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_X), src[0], constants[0]);   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Y), src[0], constants[1]);   ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Z), src[0]);   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), src[0], constants[2]);   ureg_MOV(ureg, dst[0], ureg_src(tmp));   if (semantic_name >= 0) {      src[1] = ureg_DECL_vs_input(ureg, 1);      dst[1] = ureg_DECL_output(ureg, semantic_name, 0);      ureg_MOV(ureg, dst[1], src[1]);   }   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

/** * Map a Mesa dst register to a TGSI ureg_dst register. */static struct ureg_dstdst_register( struct st_translate *t,              gl_register_file file,              GLuint index ){   switch( file ) {   case PROGRAM_UNDEFINED:      return ureg_dst_undef();   case PROGRAM_TEMPORARY:      if (ureg_dst_is_undef(t->temps[index]))         t->temps[index] = ureg_DECL_temporary( t->ureg );      return t->temps[index];   case PROGRAM_OUTPUT:      if (t->procType == TGSI_PROCESSOR_VERTEX)         assert(index < VARYING_SLOT_MAX);      else if (t->procType == TGSI_PROCESSOR_FRAGMENT)         assert(index < FRAG_RESULT_MAX);      else         assert(index < VARYING_SLOT_MAX);      assert(t->outputMapping[index] < ARRAY_SIZE(t->outputs));      return t->outputs[t->outputMapping[index]];   case PROGRAM_ADDRESS:      return t->address[index];   default:      debug_assert( 0 );      return ureg_dst_undef();   }}

static struct ureg_dstcalc_position(struct vl_mc *r, struct ureg_program *shader, struct ureg_src block_scale){   struct ureg_src vrect, vpos;   struct ureg_dst t_vpos;   struct ureg_dst o_vpos;   vrect = ureg_DECL_vs_input(shader, VS_I_RECT);   vpos = ureg_DECL_vs_input(shader, VS_I_VPOS);   t_vpos = ureg_DECL_temporary(shader);   o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);   /*    * block_scale = (VL_MACROBLOCK_WIDTH, VL_MACROBLOCK_HEIGHT) / (dst.width, dst.height)    *    * t_vpos = (vpos + vrect) * block_scale    * o_vpos.xy = t_vpos    * o_vpos.zw = vpos    */   ureg_ADD(shader, ureg_writemask(t_vpos, TGSI_WRITEMASK_XY), vpos, vrect);   ureg_MUL(shader, ureg_writemask(t_vpos, TGSI_WRITEMASK_XY), ureg_src(t_vpos), block_scale);   ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_XY), ureg_src(t_vpos));   ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_ZW), ureg_imm1f(shader, 1.0f));   return t_vpos;}

static void *create_frag_shader_rgba(struct vl_compositor *c){   struct ureg_program *shader;   struct ureg_src tc, color, sampler;   struct ureg_dst texel, fragment;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   color = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 0);   texel = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * fragment = tex(tc, sampler)    */   ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);   ureg_MUL(shader, fragment, ureg_src(texel), color);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

static struct ureg_srcvs_normalize_coords(struct ureg_program *ureg,		    struct ureg_src coords,		    struct ureg_src const0, struct ureg_src const1){    struct ureg_dst tmp = ureg_DECL_temporary(ureg);    struct ureg_src ret;    ureg_MAD(ureg, tmp, coords, const0, const1);    ret = ureg_src(tmp);    ureg_release_temporary(ureg, tmp);    return ret;}

static void *create_mismatch_vert_shader(struct vl_idct *idct){    struct ureg_program *shader;    struct ureg_src vpos;    struct ureg_src scale;    struct ureg_dst t_tex;    struct ureg_dst o_vpos, o_addr[2];    shader = ureg_create(TGSI_PROCESSOR_VERTEX);    if (!shader)        return NULL;    vpos = ureg_DECL_vs_input(shader, VS_I_VPOS);    t_tex = ureg_DECL_temporary(shader);    o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);    o_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0);    o_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1);    /*     * scale = (VL_BLOCK_WIDTH, VL_BLOCK_HEIGHT) / (dst.width, dst.height)     *     * t_vpos = vpos + 7 / VL_BLOCK_WIDTH     * o_vpos.xy = t_vpos * scale     *     * o_addr = calc_addr(...)     *     */    scale = ureg_imm2f(shader,                       (float)VL_BLOCK_WIDTH / idct->buffer_width,                       (float)VL_BLOCK_HEIGHT / idct->buffer_height);    ureg_MAD(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_XY), vpos, scale, scale);    ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_ZW), ureg_imm1f(shader, 1.0f));    ureg_MUL(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), vpos, scale);    calc_addr(shader, o_addr, ureg_src(t_tex), ureg_src(t_tex), false, false, idct->buffer_width / 4);    ureg_release_temporary(shader, t_tex);    ureg_END(shader);    return ureg_create_shader_and_destroy(shader, idct->pipe);}

static void *create_frag_shader_palette(struct vl_compositor *c, bool include_cc){   struct ureg_program *shader;   struct ureg_src csc[3];   struct ureg_src tc;   struct ureg_src sampler;   struct ureg_src palette;   struct ureg_dst texel;   struct ureg_dst fragment;   unsigned i;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   for (i = 0; include_cc && i < 3; ++i)      csc[i] = ureg_DECL_constant(shader, i);   tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 0);   palette = ureg_DECL_sampler(shader, 1);   texel = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * texel = tex(tc, sampler)    * fragment.xyz = tex(texel, palette) * csc    * fragment.a = texel.a    */   ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);   ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_src(texel));   if (include_cc) {      ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette);      for (i = 0; i < 3; ++i)         ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));   } else {      ureg_TEX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XYZ),               TGSI_TEXTURE_1D, ureg_src(texel), palette);   }   ureg_release_temporary(shader, texel);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

/** * OpenGL's fragment gl_FrontFace input is 1 for front-facing, 0 for back. * TGSI uses +1 for front, -1 for back. * This function converts the TGSI value to the GL value.  Simply clamping/ * saturating the value to [0,1] does the job. */static voidemit_face_var( struct st_translate *t,               const struct gl_program *program ){   struct ureg_program *ureg = t->ureg;   struct ureg_dst face_temp = ureg_DECL_temporary( ureg );   struct ureg_src face_input = t->inputs[t->inputMapping[VARYING_SLOT_FACE]];   /* MOV_SAT face_temp, input[face]    */   face_temp = ureg_saturate( face_temp );   ureg_MOV( ureg, face_temp, face_input );   /* Use face_temp as face input from here on:    */   t->inputs[t->inputMapping[VARYING_SLOT_FACE]] = ureg_src(face_temp);}

static struct ureg_dstcalc_line(struct ureg_program *shader){   struct ureg_dst tmp;   struct ureg_src pos;   tmp = ureg_DECL_temporary(shader);   pos = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS, TGSI_INTERPOLATE_LINEAR);   /*    * tmp.y = fraction(pos.y / 2) >= 0.5 ? 1 : 0    */   ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), pos, ureg_imm1f(shader, 0.5f));   ureg_FRC(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), ureg_src(tmp));   ureg_SGE(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), ureg_src(tmp), ureg_imm1f(shader, 0.5f));   return tmp;}

static voidmatrix_mul(struct ureg_program *shader, struct ureg_dst dst, struct ureg_dst l[2], struct ureg_dst r[2]){    struct ureg_dst tmp;    tmp = ureg_DECL_temporary(shader);    /*     * tmp.xy = dot4(m[0][0..1], m[1][0..1])     * dst = tmp.x + tmp.y     */    ureg_DP4(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X), ureg_src(l[0]), ureg_src(r[0]));    ureg_DP4(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), ureg_src(l[1]), ureg_src(r[1]));    ureg_ADD(shader, dst,             ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X),             ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y));    ureg_release_temporary(shader, tmp);}

static voidlinear_gradient(struct ureg_program *ureg,		struct ureg_dst out,		struct ureg_src pos,		struct ureg_src sampler,		struct ureg_src coords,		struct ureg_src const0124,		struct ureg_src matrow0,		struct ureg_src matrow1, struct ureg_src matrow2){    struct ureg_dst temp0 = ureg_DECL_temporary(ureg);    struct ureg_dst temp1 = ureg_DECL_temporary(ureg);    struct ureg_dst temp2 = ureg_DECL_temporary(ureg);    struct ureg_dst temp3 = ureg_DECL_temporary(ureg);    struct ureg_dst temp4 = ureg_DECL_temporary(ureg);    struct ureg_dst temp5 = ureg_DECL_temporary(ureg);    ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY), pos);    ureg_MOV(ureg,	     ureg_writemask(temp0, TGSI_WRITEMASK_Z),	     ureg_scalar(const0124, TGSI_SWIZZLE_Y));    ureg_DP3(ureg, temp1, matrow0, ureg_src(temp0));    ureg_DP3(ureg, temp2, matrow1, ureg_src(temp0));    ureg_DP3(ureg, temp3, matrow2, ureg_src(temp0));    ureg_RCP(ureg, temp3, ureg_src(temp3));    ureg_MUL(ureg, temp1, ureg_src(temp1), ureg_src(temp3));    ureg_MUL(ureg, temp2, ureg_src(temp2), ureg_src(temp3));    ureg_MOV(ureg, ureg_writemask(temp4, TGSI_WRITEMASK_X), ureg_src(temp1));    ureg_MOV(ureg, ureg_writemask(temp4, TGSI_WRITEMASK_Y), ureg_src(temp2));    ureg_MUL(ureg, temp0,	     ureg_scalar(coords, TGSI_SWIZZLE_Y),	     ureg_scalar(ureg_src(temp4), TGSI_SWIZZLE_Y));    ureg_MAD(ureg, temp1,	     ureg_scalar(coords, TGSI_SWIZZLE_X),	     ureg_scalar(ureg_src(temp4), TGSI_SWIZZLE_X), ureg_src(temp0));    ureg_MUL(ureg, temp2, ureg_src(temp1), ureg_scalar(coords, TGSI_SWIZZLE_Z));    ureg_TEX(ureg, out, TGSI_TEXTURE_1D, ureg_src(temp2), sampler);    ureg_release_temporary(ureg, temp0);    ureg_release_temporary(ureg, temp1);    ureg_release_temporary(ureg, temp2);    ureg_release_temporary(ureg, temp3);    ureg_release_temporary(ureg, temp4);    ureg_release_temporary(ureg, temp5);}

static void *create_frag_shader_video_buffer(struct vl_compositor *c){   struct ureg_program *shader;   struct ureg_src tc;   struct ureg_src csc[3];   struct ureg_src sampler[3];   struct ureg_dst texel;   struct ureg_dst fragment;   unsigned i;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   for (i = 0; i < 3; ++i) {      csc[i] = ureg_DECL_constant(shader, i);      sampler[i] = ureg_DECL_sampler(shader, i);   }   texel = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * texel.xyz = tex(tc, sampler[i])    * fragment = csc * texel    */   for (i = 0; i < 3; ++i)      ureg_TEX(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), TGSI_TEXTURE_3D, tc, sampler[i]);   ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));   for (i = 0; i < 3; ++i)      ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));   ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));   ureg_release_temporary(shader, texel);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

static voidureg_load_tex(struct ureg_program *ureg, struct ureg_dst out,              struct ureg_src coord, struct ureg_src sampler,              unsigned tex_target, bool load_level_zero, bool use_txf){   if (use_txf) {      struct ureg_dst temp = ureg_DECL_temporary(ureg);      ureg_F2I(ureg, temp, coord);      if (load_level_zero)         ureg_TXF_LZ(ureg, out, tex_target, ureg_src(temp), sampler);      else         ureg_TXF(ureg, out, tex_target, ureg_src(temp), sampler);   } else {      if (load_level_zero)         ureg_TEX_LZ(ureg, out, tex_target, coord, sampler);      else         ureg_TEX(ureg, out, tex_target, coord, sampler);   }}

voidvl_idct_stage2_vert_shader(struct vl_idct *idct, struct ureg_program *shader,                           unsigned first_output, struct ureg_dst tex){    struct ureg_src vrect, vpos;    struct ureg_src scale;    struct ureg_dst t_start;    struct ureg_dst o_l_addr[2], o_r_addr[2];    vrect = ureg_DECL_vs_input(shader, VS_I_RECT);    vpos = ureg_DECL_vs_input(shader, VS_I_VPOS);    t_start = ureg_DECL_temporary(shader);    --first_output;    o_l_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, first_output + VS_O_L_ADDR0);    o_l_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, first_output + VS_O_L_ADDR1);    o_r_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, first_output + VS_O_R_ADDR0);    o_r_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, first_output + VS_O_R_ADDR1);    scale = ureg_imm2f(shader,                       (float)VL_BLOCK_WIDTH / idct->buffer_width,                       (float)VL_BLOCK_HEIGHT / idct->buffer_height);    ureg_MUL(shader, ureg_writemask(tex, TGSI_WRITEMASK_Z),             ureg_scalar(vrect, TGSI_SWIZZLE_X),             ureg_imm1f(shader, VL_BLOCK_WIDTH / idct->nr_of_render_targets));    ureg_MUL(shader, ureg_writemask(t_start, TGSI_WRITEMASK_XY), vpos, scale);    calc_addr(shader, o_l_addr, vrect, ureg_imm1f(shader, 0.0f), false, false, VL_BLOCK_WIDTH / 4);    calc_addr(shader, o_r_addr, ureg_src(tex), ureg_src(t_start), true, false, idct->buffer_height / 4);    ureg_MOV(shader, ureg_writemask(o_r_addr[0], TGSI_WRITEMASK_Z), ureg_src(tex));    ureg_MOV(shader, ureg_writemask(o_r_addr[1], TGSI_WRITEMASK_Z), ureg_src(tex));}

/** * Emit the TGSI instructions for inverting and adjusting WPOS. * This code is unavoidable because it also depends on whether * a FBO is bound (STATE_FB_WPOS_Y_TRANSFORM). */static voidemit_wpos_adjustment( struct st_translate *t,                      const struct gl_program *program,                      boolean invert,                      GLfloat adjX, GLfloat adjY[2]){   struct ureg_program *ureg = t->ureg;   /* Fragment program uses fragment position input.    * Need to replace instances of INPUT[WPOS] with temp T    * where T = INPUT[WPOS] by y is inverted.    */   static const gl_state_index wposTransformState[STATE_LENGTH]      = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM, 0, 0, 0 };      /* XXX: note we are modifying the incoming shader here!  Need to    * do this before emitting the constant decls below, or this    * will be missed:    */   unsigned wposTransConst = _mesa_add_state_reference(program->Parameters,                                                       wposTransformState);   struct ureg_src wpostrans = ureg_DECL_constant( ureg, wposTransConst );   struct ureg_dst wpos_temp = ureg_DECL_temporary( ureg );   struct ureg_src wpos_input = t->inputs[t->inputMapping[VARYING_SLOT_POS]];   /* First, apply the coordinate shift: */   if (adjX || adjY[0] || adjY[1]) {      if (adjY[0] != adjY[1]) {         /* Adjust the y coordinate by adjY[1] or adjY[0] respectively          * depending on whether inversion is actually going to be applied          * or not, which is determined by testing against the inversion          * state variable used below, which will be either +1 or -1.          */         struct ureg_dst adj_temp = ureg_DECL_temporary(ureg);         ureg_CMP(ureg, adj_temp,                  ureg_scalar(wpostrans, invert ? 2 : 0),                  ureg_imm4f(ureg, adjX, adjY[0], 0.0f, 0.0f),                  ureg_imm4f(ureg, adjX, adjY[1], 0.0f, 0.0f));         ureg_ADD(ureg, wpos_temp, wpos_input, ureg_src(adj_temp));      } else {         ureg_ADD(ureg, wpos_temp, wpos_input,                  ureg_imm4f(ureg, adjX, adjY[0], 0.0f, 0.0f));      }      wpos_input = ureg_src(wpos_temp);   } else {      /* MOV wpos_temp, input[wpos]       */      ureg_MOV( ureg, wpos_temp, wpos_input );   }   /* Now the conditional y flip: STATE_FB_WPOS_Y_TRANSFORM.xy/zw will be    * inversion/identity, or the other way around if we're drawing to an FBO.    */   if (invert) {      /* MAD wpos_temp.y, wpos_input, wpostrans.xxxx, wpostrans.yyyy       */      ureg_MAD( ureg,                ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),                wpos_input,                ureg_scalar(wpostrans, 0),                ureg_scalar(wpostrans, 1));   } else {      /* MAD wpos_temp.y, wpos_input, wpostrans.zzzz, wpostrans.wwww       */      ureg_MAD( ureg,                ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),                wpos_input,                ureg_scalar(wpostrans, 2),                ureg_scalar(wpostrans, 3));   }   /* Use wpos_temp as position input from here on:    */   t->inputs[t->inputMapping[VARYING_SLOT_POS]] = ureg_src(wpos_temp);}

//.........这里部分代码省略.........            t->systemValues[i] = ureg_DECL_system_value(ureg, numSys, semName, 0);            if (semName == TGSI_SEMANTIC_INSTANCEID ||                semName == TGSI_SEMANTIC_VERTEXID) {               /* From Gallium perspective, these system values are always                * integer, and require native integer support.  However, if                * native integer is supported on the vertex stage but not the                * pixel stage (e.g, i915g + draw), Mesa will generate IR that                * assumes these system values are floats. To resolve the                * inconsistency, we insert a U2F.                */               struct st_context *st = st_context(ctx);               struct pipe_screen *pscreen = st->pipe->screen;               assert(procType == TGSI_PROCESSOR_VERTEX);               assert(pscreen->get_shader_param(pscreen, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_INTEGERS));               (void) pscreen;  /* silence non-debug build warnings */               if (!ctx->Const.NativeIntegers) {                  struct ureg_dst temp = ureg_DECL_local_temporary(t->ureg);                  ureg_U2F( t->ureg, ureg_writemask(temp, TGSI_WRITEMASK_X), t->systemValues[i]);                  t->systemValues[i] = ureg_scalar(ureg_src(temp), 0);               }            }            numSys++;            sysInputs &= ~(1 << i);         }      }   }   if (program->IndirectRegisterFiles & (1 << PROGRAM_TEMPORARY)) {      /* If temps are accessed with indirect addressing, declare temporaries       * in sequential order.  Else, we declare them on demand elsewhere.       */      for (i = 0; i < program->NumTemporaries; i++) {         /* XXX use TGSI_FILE_TEMPORARY_ARRAY when it's supported by ureg */         t->temps[i] = ureg_DECL_temporary( t->ureg );      }   }   /* Emit constants and immediates.  Mesa uses a single index space    * for these, so we put all the translated regs in t->constants.    */   if (program->Parameters) {      t->constants = calloc( program->Parameters->NumParameters,                             sizeof t->constants[0] );      if (t->constants == NULL) {         ret = PIPE_ERROR_OUT_OF_MEMORY;         goto out;      }      for (i = 0; i < program->Parameters->NumParameters; i++) {         switch (program->Parameters->Parameters[i].Type) {         case PROGRAM_STATE_VAR:         case PROGRAM_UNIFORM:            t->constants[i] = ureg_DECL_constant( ureg, i );            break;            /* Emit immediates only when there's no indirect addressing of             * the const buffer.             * FIXME: Be smarter and recognize param arrays:             * indirect addressing is only valid within the referenced             * array.             */         case PROGRAM_CONSTANT:            if (program->IndirectRegisterFiles & PROGRAM_ANY_CONST)               t->constants[i] = ureg_DECL_constant( ureg, i );            else               t->constants[i] = 

static void *create_frag_shader(struct vl_zscan *zscan){   struct ureg_program *shader;   struct ureg_src *vtex;   struct ureg_src samp_src, samp_scan, samp_quant;   struct ureg_dst *tmp;   struct ureg_dst quant, fragment;   unsigned i;   shader = ureg_create(PIPE_SHADER_FRAGMENT);   if (!shader)      return NULL;   vtex = MALLOC(zscan->num_channels * sizeof(struct ureg_src));   tmp = MALLOC(zscan->num_channels * sizeof(struct ureg_dst));   for (i = 0; i < zscan->num_channels; ++i)      vtex[i] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX + i, TGSI_INTERPOLATE_LINEAR);   samp_src = ureg_DECL_sampler(shader, 0);   samp_scan = ureg_DECL_sampler(shader, 1);   samp_quant = ureg_DECL_sampler(shader, 2);   for (i = 0; i < zscan->num_channels; ++i)      tmp[i] = ureg_DECL_temporary(shader);   quant = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * tmp.x = tex(vtex, 1)    * tmp.y = vtex.z    * fragment = tex(tmp, 0) * quant    */   for (i = 0; i < zscan->num_channels; ++i)      ureg_TEX(shader, ureg_writemask(tmp[i], TGSI_WRITEMASK_X), TGSI_TEXTURE_2D, vtex[i], samp_scan);   for (i = 0; i < zscan->num_channels; ++i)      ureg_MOV(shader, ureg_writemask(tmp[i], TGSI_WRITEMASK_Y), ureg_scalar(vtex[i], TGSI_SWIZZLE_W));   for (i = 0; i < zscan->num_channels; ++i) {      ureg_TEX(shader, ureg_writemask(tmp[0], TGSI_WRITEMASK_X << i), TGSI_TEXTURE_2D, ureg_src(tmp[i]), samp_src);      ureg_TEX(shader, ureg_writemask(quant, TGSI_WRITEMASK_X << i), TGSI_TEXTURE_3D, vtex[i], samp_quant);   }   ureg_MUL(shader, quant, ureg_src(quant), ureg_imm1f(shader, 16.0f));   ureg_MUL(shader, fragment, ureg_src(tmp[0]), ureg_src(quant));   for (i = 0; i < zscan->num_channels; ++i)      ureg_release_temporary(shader, tmp[i]);   ureg_END(shader);   FREE(vtex);   FREE(tmp);   return ureg_create_shader_and_destroy(shader, zscan->pipe);}

static void *create_fs(struct pipe_context *pipe, unsigned fs_traits){    struct ureg_program *ureg;    struct ureg_src /*dst_sampler, */ src_sampler, mask_sampler;    struct ureg_src /*dst_pos, */ src_input, mask_pos;    struct ureg_dst src, mask;    struct ureg_dst out;    struct ureg_src imm0 = { 0 };    unsigned has_mask = (fs_traits & FS_MASK) != 0;    unsigned is_fill = (fs_traits & FS_FILL) != 0;    unsigned is_composite = (fs_traits & FS_COMPOSITE) != 0;    unsigned is_solid = (fs_traits & FS_SOLID_FILL) != 0;    unsigned is_lingrad = (fs_traits & FS_LINGRAD_FILL) != 0;    unsigned is_radgrad = (fs_traits & FS_RADGRAD_FILL) != 0;    unsigned comp_alpha_mask = fs_traits & FS_COMPONENT_ALPHA;    unsigned is_yuv = (fs_traits & FS_YUV) != 0;    unsigned src_repeat_none = (fs_traits & FS_SRC_REPEAT_NONE) != 0;    unsigned mask_repeat_none = (fs_traits & FS_MASK_REPEAT_NONE) != 0;    unsigned src_swizzle = (fs_traits & FS_SRC_SWIZZLE_RGB) != 0;    unsigned mask_swizzle = (fs_traits & FS_MASK_SWIZZLE_RGB) != 0;    unsigned src_set_alpha = (fs_traits & FS_SRC_SET_ALPHA) != 0;    unsigned mask_set_alpha = (fs_traits & FS_MASK_SET_ALPHA) != 0;    unsigned src_luminance = (fs_traits & FS_SRC_LUMINANCE) != 0;    unsigned mask_luminance = (fs_traits & FS_MASK_LUMINANCE) != 0;    unsigned dst_luminance = (fs_traits & FS_DST_LUMINANCE) != 0;#if 0    print_fs_traits(fs_traits);#else    (void)print_fs_traits;#endif    ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);    if (ureg == NULL)	return 0;    /* it has to be either a fill, a composite op or a yuv conversion */    debug_assert((is_fill ^ is_composite) ^ is_yuv);    (void)is_yuv;    out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);    if (src_repeat_none || mask_repeat_none ||	src_set_alpha || mask_set_alpha || src_luminance) {	imm0 = ureg_imm4f(ureg, 0, 0, 0, 1);    }    if (is_composite) {	src_sampler = ureg_DECL_sampler(ureg, 0);	src_input = ureg_DECL_fs_input(ureg,				       TGSI_SEMANTIC_GENERIC, 0,				       TGSI_INTERPOLATE_PERSPECTIVE);    } else if (is_fill) {	if (is_solid)	    src_input = ureg_DECL_fs_input(ureg,					   TGSI_SEMANTIC_COLOR, 0,					   TGSI_INTERPOLATE_PERSPECTIVE);	else	    src_input = ureg_DECL_fs_input(ureg,					   TGSI_SEMANTIC_POSITION, 0,					   TGSI_INTERPOLATE_PERSPECTIVE);    } else {	debug_assert(is_yuv);	return create_yuv_shader(pipe, ureg);    }    if (has_mask) {	mask_sampler = ureg_DECL_sampler(ureg, 1);	mask_pos = ureg_DECL_fs_input(ureg,				      TGSI_SEMANTIC_GENERIC, 1,				      TGSI_INTERPOLATE_PERSPECTIVE);    }#if 0				/* unused right now */    dst_sampler = ureg_DECL_sampler(ureg, 2);    dst_pos = ureg_DECL_fs_input(ureg,				 TGSI_SEMANTIC_POSITION, 2,				 TGSI_INTERPOLATE_PERSPECTIVE);#endif    if (is_composite) {	if (has_mask || src_luminance || dst_luminance)	    src = ureg_DECL_temporary(ureg);	else	    src = out;	xrender_tex(ureg, src, src_input, src_sampler, imm0,		    src_repeat_none, src_swizzle, src_set_alpha);    } else if (is_fill) {	if (is_solid) {	    if (has_mask || src_luminance || dst_luminance)		src = ureg_dst(src_input);	    else		ureg_MOV(ureg, out, src_input);	} else if (is_lingrad || is_radgrad) {	    struct ureg_src coords, const0124, matrow0, matrow1, matrow2;	    if (has_mask || src_luminance || dst_luminance)		src = ureg_DECL_temporary(ureg);	    else		src = out;//.........这里部分代码省略.........

static void *create_vert_shader(struct vl_zscan *zscan){   struct ureg_program *shader;   struct ureg_src scale;   struct ureg_src vrect, vpos, block_num;   struct ureg_dst tmp;   struct ureg_dst o_vpos;   struct ureg_dst *o_vtex;   unsigned i;   shader = ureg_create(PIPE_SHADER_VERTEX);   if (!shader)      return NULL;   o_vtex = MALLOC(zscan->num_channels * sizeof(struct ureg_dst));   scale = ureg_imm2f(shader,      (float)VL_BLOCK_WIDTH / zscan->buffer_width,      (float)VL_BLOCK_HEIGHT / zscan->buffer_height);   vrect = ureg_DECL_vs_input(shader, VS_I_RECT);   vpos = ureg_DECL_vs_input(shader, VS_I_VPOS);   block_num = ureg_DECL_vs_input(shader, VS_I_BLOCK_NUM);   tmp = ureg_DECL_temporary(shader);   o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);   for (i = 0; i < zscan->num_channels; ++i)      o_vtex[i] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX + i);   /*    * o_vpos.xy = (vpos + vrect) * scale    * o_vpos.zw = 1.0f    *    * tmp.xy = InstanceID / blocks_per_line    * tmp.x = frac(tmp.x)    * tmp.y = floor(tmp.y)    *    * o_vtex.x = vrect.x / blocks_per_line + tmp.x    * o_vtex.y = vrect.y    * o_vtex.z = tmp.z * blocks_per_line / blocks_total    */   ureg_ADD(shader, ureg_writemask(tmp, TGSI_WRITEMASK_XY), vpos, vrect);   ureg_MUL(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_XY), ureg_src(tmp), scale);   ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_ZW), ureg_imm1f(shader, 1.0f));   ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_XW), ureg_scalar(block_num, TGSI_SWIZZLE_X),            ureg_imm1f(shader, 1.0f / zscan->blocks_per_line));   ureg_FRC(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X));   ureg_FLR(shader, ureg_writemask(tmp, TGSI_WRITEMASK_W), ureg_src(tmp));   for (i = 0; i < zscan->num_channels; ++i) {      ureg_ADD(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X), ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y),               ureg_imm1f(shader, 1.0f / (zscan->blocks_per_line * VL_BLOCK_WIDTH)                * (i - (signed)zscan->num_channels / 2)));      ureg_MAD(shader, ureg_writemask(o_vtex[i], TGSI_WRITEMASK_X), vrect,               ureg_imm1f(shader, 1.0f / zscan->blocks_per_line), ureg_src(tmp));      ureg_MOV(shader, ureg_writemask(o_vtex[i], TGSI_WRITEMASK_Y), vrect);      ureg_MOV(shader, ureg_writemask(o_vtex[i], TGSI_WRITEMASK_Z), vpos);      ureg_MUL(shader, ureg_writemask(o_vtex[i], TGSI_WRITEMASK_W), ureg_src(tmp),               ureg_imm1f(shader, (float)zscan->blocks_per_line / zscan->blocks_total));   }   ureg_release_temporary(shader, tmp);   ureg_END(shader);   FREE(o_vtex);   return ureg_create_shader_and_destroy(shader, zscan->pipe);}

static void *create_deint_frag_shader(struct vl_deint_filter *filter, unsigned field,                         struct vertex2f *sizes, bool spatial_filter){   struct ureg_program *shader;   struct ureg_src i_vtex;   struct ureg_src sampler_cur;   struct ureg_src sampler_prevprev;   struct ureg_src sampler_prev;   struct ureg_src sampler_next;   struct ureg_dst o_fragment;   struct ureg_dst t_tex;   struct ureg_dst t_comp_top, t_comp_bot;   struct ureg_dst t_diff;   struct ureg_dst t_a, t_b;   struct ureg_dst t_weave, t_linear;   shader = ureg_create(PIPE_SHADER_FRAGMENT);   if (!shader) {      return NULL;   }   t_tex = ureg_DECL_temporary(shader);   t_comp_top = ureg_DECL_temporary(shader);   t_comp_bot = ureg_DECL_temporary(shader);   t_diff = ureg_DECL_temporary(shader);   t_a = ureg_DECL_temporary(shader);   t_b = ureg_DECL_temporary(shader);   t_weave = ureg_DECL_temporary(shader);   t_linear = ureg_DECL_temporary(shader);   i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler_prevprev = ureg_DECL_sampler(shader, 0);   sampler_prev = ureg_DECL_sampler(shader, 1);   sampler_cur = ureg_DECL_sampler(shader, 2);   sampler_next = ureg_DECL_sampler(shader, 3);   o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   // we don't care about ZW interpolation (allows better optimization)   ureg_MOV(shader, t_tex, i_vtex);   ureg_MOV(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_ZW),            ureg_imm1f(shader, 0));   // sample between texels for cheap lowpass   ureg_ADD(shader, t_comp_top, ureg_src(t_tex),            ureg_imm4f(shader, sizes->x * 0.5f, sizes->y * -0.5f, 0, 0));   ureg_ADD(shader, t_comp_bot, ureg_src(t_tex),            ureg_imm4f(shader, sizes->x * -0.5f, sizes->y * 0.5f, 1.0f, 0));   if (field == 0) {      /* interpolating top field -> current field is a bottom field */      // cur vs prev2      ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_cur);      ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_prevprev);      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_a), ureg_negate(ureg_src(t_b)));      // prev vs next      ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_prev);      ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_next);      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_Y), ureg_src(t_a), ureg_negate(ureg_src(t_b)));   } else {      /* interpolating bottom field -> current field is a top field */      // cur vs prev2      ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_cur);      ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_prevprev);      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_a), ureg_negate(ureg_src(t_b)));      // prev vs next      ureg_TEX(shader, t_a, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_prev);      ureg_TEX(shader, t_b, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_next);      ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_Y), ureg_src(t_a), ureg_negate(ureg_src(t_b)));   }   // absolute maximum of differences   ureg_MAX(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_abs(ureg_src(t_diff)),            ureg_scalar(ureg_abs(ureg_src(t_diff)), TGSI_SWIZZLE_Y));   if (field == 0) {      /* weave with prev top field */      ureg_TEX(shader, t_weave, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_tex), sampler_prev);      /* get linear interpolation from current bottom field */      ureg_ADD(shader, t_comp_top, ureg_src(t_tex), ureg_imm4f(shader, 0, sizes->y * -1.0f, 1.0f, 0));      ureg_TEX(shader, t_linear, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_top), sampler_cur);   } else {      /* weave with prev bottom field */      ureg_ADD(shader, t_comp_bot, ureg_src(t_tex), ureg_imm4f(shader, 0, 0, 1.0f, 0));      ureg_TEX(shader, t_weave, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_prev);      /* get linear interpolation from current top field */      ureg_ADD(shader, t_comp_bot, ureg_src(t_tex), ureg_imm4f(shader, 0, sizes->y * 1.0f, 0, 0));      ureg_TEX(shader, t_linear, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_comp_bot), sampler_cur);   }   // mix between weave and linear   // fully weave if diff < 6 (0.02353), fully interpolate if diff > 14 (0.05490)   ureg_ADD(shader, ureg_writemask(t_diff, TGSI_WRITEMASK_X), ureg_src(t_diff),            ureg_imm4f(shader, -0.02353f, 0, 0, 0));   ureg_MUL(shader, ureg_saturate(ureg_writemask(t_diff, TGSI_WRITEMASK_X)),            ureg_src(t_diff), ureg_imm4f(shader, 31.8750f, 0, 0, 0));   ureg_LRP(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_X), ureg_src(t_diff),            ureg_src(t_linear), ureg_src(t_weave));   ureg_MOV(shader, o_fragment, ureg_scalar(ureg_src(t_tex), TGSI_SWIZZLE_X));//.........这里部分代码省略.........

static void *create_frag_shader_weave(struct vl_compositor *c){   struct ureg_program *shader;   struct ureg_src i_tc[2];   struct ureg_src csc[3];   struct ureg_src sampler[3];   struct ureg_dst t_tc[2];   struct ureg_dst t_texel[2];   struct ureg_dst o_fragment;   unsigned i, j;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   i_tc[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP, TGSI_INTERPOLATE_LINEAR);   i_tc[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM, TGSI_INTERPOLATE_LINEAR);   for (i = 0; i < 3; ++i) {      csc[i] = ureg_DECL_constant(shader, i);      sampler[i] = ureg_DECL_sampler(shader, i);   }   for (i = 0; i < 2; ++i) {      t_tc[i] = ureg_DECL_temporary(shader);      t_texel[i] = ureg_DECL_temporary(shader);   }   o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /* calculate the texture offsets    * t_tc.x = i_tc.x    * t_tc.y = (round(i_tc.y) + 0.5) / height * 2    */   for (i = 0; i < 2; ++i) {      ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_X), i_tc[i]);      ureg_ROUND(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ), i_tc[i]);      ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_W),               ureg_imm1f(shader, i ? 0.75f : 0.25f));      ureg_ADD(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ),               ureg_src(t_tc[i]), ureg_imm1f(shader, 0.5f));      ureg_MUL(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_Y),               ureg_src(t_tc[i]), ureg_scalar(i_tc[0], TGSI_SWIZZLE_W));      ureg_MUL(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_Z),               ureg_src(t_tc[i]), ureg_scalar(i_tc[1], TGSI_SWIZZLE_W));   }   /* fetch the texels    * texel[0..1].x = tex(t_tc[0..1][0])    * texel[0..1].y = tex(t_tc[0..1][1])    * texel[0..1].z = tex(t_tc[0..1][2])    */   for (i = 0; i < 2; ++i)      for (j = 0; j < 3; ++j) {         struct ureg_src src = ureg_swizzle(ureg_src(t_tc[i]),            TGSI_SWIZZLE_X, j ? TGSI_SWIZZLE_Z : TGSI_SWIZZLE_Y, TGSI_SWIZZLE_W, TGSI_SWIZZLE_W);         ureg_TEX(shader, ureg_writemask(t_texel[i], TGSI_WRITEMASK_X << j),                  TGSI_TEXTURE_3D, src, sampler[j]);      }   /* calculate linear interpolation factor    * factor = |round(i_tc.y) - i_tc.y| * 2    */   ureg_ROUND(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ), i_tc[0]);   ureg_ADD(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ),            ureg_src(t_tc[0]), ureg_negate(i_tc[0]));   ureg_MUL(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_XY),            ureg_abs(ureg_src(t_tc[0])), ureg_imm1f(shader, 2.0f));   ureg_LRP(shader, t_texel[0], ureg_swizzle(ureg_src(t_tc[0]),            TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_Z),            ureg_src(t_texel[1]), ureg_src(t_texel[0]));   /* and finally do colour space transformation    * fragment = csc * texel    */   ureg_MOV(shader, ureg_writemask(t_texel[0], TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));   for (i = 0; i < 3; ++i)      ureg_DP4(shader, ureg_writemask(o_fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(t_texel[0]));   ureg_MOV(shader, ureg_writemask(o_fragment, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));   for (i = 0; i < 2; ++i) {      ureg_release_temporary(shader, t_texel[i]);      ureg_release_temporary(shader, t_tc[i]);   }   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

static void *create_vert_shader(struct vl_compositor *c){   struct ureg_program *shader;   struct ureg_src vpos, vtex, color;   struct ureg_dst tmp;   struct ureg_dst o_vpos, o_vtex, o_color;   struct ureg_dst o_vtop, o_vbottom;   shader = ureg_create(TGSI_PROCESSOR_VERTEX);   if (!shader)      return false;   vpos = ureg_DECL_vs_input(shader, 0);   vtex = ureg_DECL_vs_input(shader, 1);   color = ureg_DECL_vs_input(shader, 2);   tmp = ureg_DECL_temporary(shader);   o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);   o_color = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR);   o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX);   o_vtop = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP);   o_vbottom = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM);   /*    * o_vpos = vpos    * o_vtex = vtex    * o_color = color    */   ureg_MOV(shader, o_vpos, vpos);   ureg_MOV(shader, o_vtex, vtex);   ureg_MOV(shader, o_color, color);   /*    * tmp.x = vtex.w / 2    * tmp.y = vtex.w / 4    *    * o_vtop.x = vtex.x    * o_vtop.y = vtex.y * tmp.x + 0.25f    * o_vtop.z = vtex.y * tmp.y + 0.25f    * o_vtop.w = 1 / tmp.x    *    * o_vbottom.x = vtex.x    * o_vbottom.y = vtex.y * tmp.x - 0.25f    * o_vbottom.z = vtex.y * tmp.y - 0.25f    * o_vbottom.w = 1 / tmp.y    */   ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X),            ureg_scalar(vtex, TGSI_SWIZZLE_W), ureg_imm1f(shader, 0.5f));   ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y),            ureg_scalar(vtex, TGSI_SWIZZLE_W), ureg_imm1f(shader, 0.25f));   ureg_MOV(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_X), vtex);   ureg_MAD(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_Y), ureg_scalar(vtex, TGSI_SWIZZLE_Y),            ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), ureg_imm1f(shader, 0.25f));   ureg_MAD(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_Z), ureg_scalar(vtex, TGSI_SWIZZLE_Y),            ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y), ureg_imm1f(shader, 0.25f));   ureg_RCP(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_W),            ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X));   ureg_MOV(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_X), vtex);   ureg_MAD(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_Y), ureg_scalar(vtex, TGSI_SWIZZLE_Y),            ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), ureg_imm1f(shader, -0.25f));   ureg_MAD(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_Z), ureg_scalar(vtex, TGSI_SWIZZLE_Y),            ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y), ureg_imm1f(shader, -0.25f));   ureg_RCP(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_W),            ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y));   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}