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_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));
ureg_release_temporary(shader, t_tex);
ureg_release_temporary(shader, t_comp_top);
ureg_release_temporary(shader, t_comp_bot);
ureg_release_temporary(shader, t_diff);
ureg_release_temporary(shader, t_a);
ureg_release_temporary(shader, t_b);
ureg_release_temporary(shader, t_weave);
ureg_release_temporary(shader, t_linear);
ureg_END(shader);
return ureg_create_shader_and_destroy(shader, filter->pipe);
}
void *
util_make_fs_msaa_resolve_bilinear(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, top, bottom;
struct ureg_dst tmp_coord[4], tmp_sum[4];
unsigned i, c;
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);
for (c = 0; c < 4; c++)
tmp_sum[c] = ureg_DECL_temporary(ureg);
for (c = 0; c < 4; c++)
tmp_coord[c] = ureg_DECL_temporary(ureg);
tmp = ureg_DECL_temporary(ureg);
top = ureg_DECL_temporary(ureg);
bottom = ureg_DECL_temporary(ureg);
/* Instructions. */
for (c = 0; c < 4; c++)
ureg_MOV(ureg, tmp_sum[c], ureg_imm1f(ureg, 0));
/* Get 4 texture coordinates for the bilinear filter. */
ureg_F2U(ureg, tmp_coord[0], coord); /* top-left */
ureg_UADD(ureg, tmp_coord[1], ureg_src(tmp_coord[0]),
ureg_imm4u(ureg, 1, 0, 0, 0)); /* top-right */
ureg_UADD(ureg, tmp_coord[2], ureg_src(tmp_coord[0]),
ureg_imm4u(ureg, 0, 1, 0, 0)); /* bottom-left */
ureg_UADD(ureg, tmp_coord[3], ureg_src(tmp_coord[0]),
ureg_imm4u(ureg, 1, 1, 0, 0)); /* bottom-right */
for (i = 0; i < nr_samples; i++) {
for (c = 0; c < 4; c++) {
/* Read one sample. */
ureg_MOV(ureg, ureg_writemask(tmp_coord[c], TGSI_WRITEMASK_W),
ureg_imm1u(ureg, i));
ureg_TXF(ureg, tmp, tgsi_tex, ureg_src(tmp_coord[c]), 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[c], ureg_src(tmp_sum[c]), ureg_src(tmp));
}
}
/* Calculate the average. */
for (c = 0; c < 4; c++)
ureg_MUL(ureg, tmp_sum[c], ureg_src(tmp_sum[c]),
ureg_imm1f(ureg, 1.0 / nr_samples));
/* Take the 4 average values and apply a standard bilinear filter. */
ureg_FRC(ureg, tmp, coord);
ureg_LRP(ureg, top,
ureg_scalar(ureg_src(tmp), 0),
ureg_src(tmp_sum[1]),
ureg_src(tmp_sum[0]));
ureg_LRP(ureg, bottom,
ureg_scalar(ureg_src(tmp), 0),
ureg_src(tmp_sum[3]),
ureg_src(tmp_sum[2]));
ureg_LRP(ureg, tmp,
ureg_scalar(ureg_src(tmp), 1),
ureg_src(bottom),
ureg_src(top));
/* Convert to the texture format and return. */
if (stype == TGSI_RETURN_TYPE_UINT)
ureg_F2U(ureg, out, ureg_src(tmp));
else if (stype == TGSI_RETURN_TYPE_SINT)
ureg_F2I(ureg, out, ureg_src(tmp));
else
ureg_MOV(ureg, out, ureg_src(tmp));
ureg_END(ureg);
return ureg_create_shader_and_destroy(ureg, pipe);
}
