src/gallium/auxiliary/vl/vl_idct.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Christian König
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include <assert.h>
  29
  30 #include <pipe/p_context.h>
  31 #include <pipe/p_screen.h>
  32
  33 #include <util/u_draw.h>
  34 #include <util/u_sampler.h>
  35
  36 #include <tgsi/tgsi_ureg.h>
  37
  38 #include "vl_defines.h"
  39 #include "vl_types.h"
  40 #include "vl_vertex_buffers.h"
  41 #include "vl_idct.h"
  42
  43 enum VS_OUTPUT
  44 {
  45    VS_O_VPOS,
  46    VS_O_L_ADDR0,
  47    VS_O_L_ADDR1,
  48    VS_O_R_ADDR0,
  49    VS_O_R_ADDR1
  50 };
  51
  52 static const float const_matrix[8][8] = {
  53    {  0.3535530f,  0.3535530f,  0.3535530f,  0.3535530f,  0.3535530f,  0.3535530f,  0.353553f,  0.3535530f },
  54    {  0.4903930f,  0.4157350f,  0.2777850f,  0.0975451f, -0.0975452f, -0.2777850f, -0.415735f, -0.4903930f },
  55    {  0.4619400f,  0.1913420f, -0.1913420f, -0.4619400f, -0.4619400f, -0.1913420f,  0.191342f,  0.4619400f },
  56    {  0.4157350f, -0.0975452f, -0.4903930f, -0.2777850f,  0.2777850f,  0.4903930f,  0.097545f, -0.4157350f },
  57    {  0.3535530f, -0.3535530f, -0.3535530f,  0.3535540f,  0.3535530f, -0.3535540f, -0.353553f,  0.3535530f },
  58    {  0.2777850f, -0.4903930f,  0.0975452f,  0.4157350f, -0.4157350f, -0.0975451f,  0.490393f, -0.2777850f },
  59    {  0.1913420f, -0.4619400f,  0.4619400f, -0.1913420f, -0.1913410f,  0.4619400f, -0.461940f,  0.1913420f },
  60    {  0.0975451f, -0.2777850f,  0.4157350f, -0.4903930f,  0.4903930f, -0.4157350f,  0.277786f, -0.0975458f }
  61 };
  62
  63 static void
  64 calc_addr(struct ureg_program *shader, struct ureg_dst addr[2],
  65           struct ureg_src tc, struct ureg_src start, bool right_side,
  66           bool transposed, float size)
  67 {
  68    unsigned wm_start = (right_side == transposed) ? TGSI_WRITEMASK_X : TGSI_WRITEMASK_Y;
  69    unsigned sw_start = right_side ? TGSI_SWIZZLE_Y : TGSI_SWIZZLE_X;
  70
  71    unsigned wm_tc = (right_side == transposed) ? TGSI_WRITEMASK_Y : TGSI_WRITEMASK_X;
  72    unsigned sw_tc = right_side ? TGSI_SWIZZLE_X : TGSI_SWIZZLE_Y;
  73
  74    /*
  75     * addr[0..1].(start) = right_side ? start.x : tc.x
  76     * addr[0..1].(tc) = right_side ? tc.y : start.y
  77     * addr[0..1].z = tc.z
  78     * addr[1].(start) += 1.0f / scale
  79     */
  80    ureg_MOV(shader, ureg_writemask(addr[0], wm_start), ureg_scalar(start, sw_start));
  81    ureg_MOV(shader, ureg_writemask(addr[0], wm_tc), ureg_scalar(tc, sw_tc));
  82    ureg_MOV(shader, ureg_writemask(addr[0], TGSI_WRITEMASK_Z), tc);
  83
  84    ureg_ADD(shader, ureg_writemask(addr[1], wm_start), ureg_scalar(start, sw_start), ureg_imm1f(shader, 1.0f / size));
  85    ureg_MOV(shader, ureg_writemask(addr[1], wm_tc), ureg_scalar(tc, sw_tc));
  86    ureg_MOV(shader, ureg_writemask(addr[1], TGSI_WRITEMASK_Z), tc);
  87 }
  88
  89 static void *
  90 create_vert_shader(struct vl_idct *idct, bool matrix_stage)
  91 {
  92    struct ureg_program *shader;
  93    struct ureg_src vrect, vpos, vblock, eb;
  94    struct ureg_src scale, blocks_xy;
  95    struct ureg_dst t_tex, t_start;
  96    struct ureg_dst o_vpos, o_l_addr[2], o_r_addr[2];
  97    unsigned label;
  98
  99    shader = ureg_create(TGSI_PROCESSOR_VERTEX);
 100    if (!shader)
 101       return NULL;
 102
 103    t_tex = ureg_DECL_temporary(shader);
 104    t_start = ureg_DECL_temporary(shader);
 105
 106    vrect = ureg_DECL_vs_input(shader, VS_I_RECT);
 107    vpos = ureg_DECL_vs_input(shader, VS_I_VPOS);
 108    vblock = ureg_swizzle(vrect, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_W, TGSI_SWIZZLE_X, TGSI_SWIZZLE_X);
 109
 110    o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);
 111
 112    eb = ureg_DECL_vs_input(shader, VS_I_EB);
 113
 114    o_l_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0);
 115    o_l_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1);
 116
 117    o_r_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR0);
 118    o_r_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR1);
 119
 120    /*
 121     * scale = (BLOCK_WIDTH, BLOCK_HEIGHT) / (dst.width, dst.height)
 122     * blocks_xy = (blocks_x, blocks_y)
 123     *
 124     * if eb.(vblock.y, vblock.x)
 125     *    o_vpos.xy = -1
 126     * else
 127     *    t_tex = vpos * blocks_xy + vblock
 128     *    t_start = t_tex * scale
 129     *    t_tex = t_tex + vrect
 130     *    o_vpos.xy = t_tex * scale
 131     *
 132     *    o_l_addr = calc_addr(...)
 133     *    o_r_addr = calc_addr(...)
 134     * endif
 135     * o_vpos.zw = vpos
 136     *
 137     */
 138
 139    scale = ureg_imm2f(shader,
 140       (float)BLOCK_WIDTH / idct->buffer_width,
 141       (float)BLOCK_HEIGHT / idct->buffer_height);
 142
 143    blocks_xy = ureg_imm2f(shader, idct->blocks_x, idct->blocks_y);
 144
 145    if (idct->blocks_x > 1 || idct->blocks_y > 1) {
 146       ureg_CMP(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY),
 147          ureg_negate(ureg_scalar(vblock, TGSI_SWIZZLE_Y)),
 148          ureg_swizzle(eb, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_W, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_W),
 149          ureg_swizzle(eb, TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y, TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y));
 150
 151       ureg_CMP(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_X),
 152          ureg_negate(ureg_scalar(vblock, TGSI_SWIZZLE_X)),
 153          ureg_scalar(ureg_src(t_tex), TGSI_SWIZZLE_Y),
 154          ureg_scalar(ureg_src(t_tex), TGSI_SWIZZLE_X));
 155
 156       eb = ureg_src(t_tex);
 157    }
 158
 159    ureg_IF(shader, ureg_scalar(eb, TGSI_SWIZZLE_X), &label);
 160
 161       ureg_MOV(shader, o_vpos, ureg_imm1f(shader, -1.0f));
 162
 163    ureg_fixup_label(shader, label, ureg_get_instruction_number(shader));
 164    ureg_ELSE(shader, &label);
 165
 166       ureg_MAD(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), vpos, blocks_xy, vblock);
 167       ureg_MUL(shader, ureg_writemask(t_start, TGSI_WRITEMASK_XY), ureg_src(t_tex), scale);
 168
 169       ureg_ADD(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), ureg_src(t_tex), vrect);
 170
 171       ureg_MUL(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), ureg_src(t_tex), scale);
 172       ureg_MUL(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_Z),
 173          ureg_scalar(vrect, TGSI_SWIZZLE_X),
 174          ureg_imm1f(shader, BLOCK_WIDTH / idct->nr_of_render_targets));
 175
 176       ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_XY), ureg_src(t_tex));
 177
 178       if(matrix_stage) {
 179          calc_addr(shader, o_l_addr, ureg_src(t_tex), ureg_src(t_start), false, false, idct->buffer_width / 4);
 180          calc_addr(shader, o_r_addr, vrect, ureg_imm1f(shader, 0.0f), true, true, BLOCK_WIDTH / 4);
 181       } else {
 182          calc_addr(shader, o_l_addr, vrect, ureg_imm1f(shader, 0.0f), false, false, BLOCK_WIDTH / 4);
 183          calc_addr(shader, o_r_addr, ureg_src(t_tex), ureg_src(t_start), true, false, idct->buffer_height / 4);
 184       }
 185
 186    ureg_fixup_label(shader, label, ureg_get_instruction_number(shader));
 187    ureg_ENDIF(shader);
 188
 189    ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_ZW), vpos);
 190
 191    ureg_release_temporary(shader, t_tex);
 192    ureg_release_temporary(shader, t_start);
 193
 194    ureg_END(shader);
 195
 196    return ureg_create_shader_and_destroy(shader, idct->pipe);
 197 }
 198
 199 static void
 200 increment_addr(struct ureg_program *shader, struct ureg_dst daddr[2],
 201                struct ureg_src saddr[2], bool right_side, bool transposed,
 202                int pos, float size)
 203 {
 204    unsigned wm_start = (right_side == transposed) ? TGSI_WRITEMASK_X : TGSI_WRITEMASK_Y;
 205    unsigned wm_tc = (right_side == transposed) ? TGSI_WRITEMASK_Y : TGSI_WRITEMASK_X;
 206
 207    /*
 208     * daddr[0..1].(start) = saddr[0..1].(start)
 209     * daddr[0..1].(tc) = saddr[0..1].(tc)
 210     */
 211
 212    ureg_MOV(shader, ureg_writemask(daddr[0], wm_start), saddr[0]);
 213    ureg_ADD(shader, ureg_writemask(daddr[0], wm_tc), saddr[0], ureg_imm1f(shader, pos / size));
 214    ureg_MOV(shader, ureg_writemask(daddr[1], wm_start), saddr[1]);
 215    ureg_ADD(shader, ureg_writemask(daddr[1], wm_tc), saddr[1], ureg_imm1f(shader, pos / size));
 216 }
 217
 218 static void
 219 fetch_four(struct ureg_program *shader, struct ureg_dst m[2], struct ureg_src addr[2], struct ureg_src sampler)
 220 {
 221    ureg_TEX(shader, m[0], TGSI_TEXTURE_3D, addr[0], sampler);
 222    ureg_TEX(shader, m[1], TGSI_TEXTURE_3D, addr[1], sampler);
 223 }
 224
 225 static void
 226 matrix_mul(struct ureg_program *shader, struct ureg_dst dst, struct ureg_dst l[2], struct ureg_dst r[2])
 227 {
 228    struct ureg_dst tmp;
 229
 230    tmp = ureg_DECL_temporary(shader);
 231
 232    /*
 233     * tmp.xy = dot4(m[0][0..1], m[1][0..1])
 234     * dst = tmp.x + tmp.y
 235     */
 236    ureg_DP4(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X), ureg_src(l[0]), ureg_src(r[0]));
 237    ureg_DP4(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), ureg_src(l[1]), ureg_src(r[1]));
 238    ureg_ADD(shader, dst,
 239       ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X),
 240       ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y));
 241
 242    ureg_release_temporary(shader, tmp);
 243 }
 244
 245 static void *
 246 create_matrix_frag_shader(struct vl_idct *idct)
 247 {
 248    struct ureg_program *shader;
 249
 250    struct ureg_src l_addr[2], r_addr[2];
 251
 252    struct ureg_dst l[4][2], r[2];
 253    struct ureg_dst fragment[idct->nr_of_render_targets];
 254
 255    unsigned i, j;
 256
 257    shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
 258    if (!shader)
 259       return NULL;
 260
 261    l_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0, TGSI_INTERPOLATE_LINEAR);
 262    l_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1, TGSI_INTERPOLATE_LINEAR);
 263
 264    r_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR0, TGSI_INTERPOLATE_LINEAR);
 265    r_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR1, TGSI_INTERPOLATE_LINEAR);
 266
 267    for (i = 0; i < idct->nr_of_render_targets; ++i)
 268        fragment[i] = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, i);
 269
 270    for (i = 0; i < 4; ++i) {
 271       l[i][0] = ureg_DECL_temporary(shader);
 272       l[i][1] = ureg_DECL_temporary(shader);
 273    }
 274
 275    r[0] = ureg_DECL_temporary(shader);
 276    r[1] = ureg_DECL_temporary(shader);
 277
 278    for (i = 1; i < 4; ++i) {
 279       increment_addr(shader, l[i], l_addr, false, false, i, idct->buffer_height);
 280    }
 281
 282    for (i = 0; i < 4; ++i) {
 283       struct ureg_src s_addr[2];
 284       s_addr[0] = i == 0 ? l_addr[0] : ureg_src(l[i][0]);
 285       s_addr[1] = i == 0 ? l_addr[1] : ureg_src(l[i][1]);
 286       fetch_four(shader, l[i], s_addr, ureg_DECL_sampler(shader, 1));
 287    }
 288
 289    for (i = 0; i < idct->nr_of_render_targets; ++i) {
 290       if(i > 0)
 291          increment_addr(shader, r, r_addr, true, true, i, BLOCK_HEIGHT);
 292
 293       struct ureg_src s_addr[2] = { ureg_src(r[0]), ureg_src(r[1]) };
 294       s_addr[0] = i == 0 ? r_addr[0] : ureg_src(r[0]);
 295       s_addr[1] = i == 0 ? r_addr[1] : ureg_src(r[1]);
 296       fetch_four(shader, r, s_addr, ureg_DECL_sampler(shader, 0));
 297
 298       for (j = 0; j < 4; ++j) {
 299          matrix_mul(shader, ureg_writemask(fragment[i], TGSI_WRITEMASK_X << j), l[j], r);
 300       }
 301    }
 302
 303    for (i = 0; i < 4; ++i) {
 304       ureg_release_temporary(shader, l[i][0]);
 305       ureg_release_temporary(shader, l[i][1]);
 306    }
 307    ureg_release_temporary(shader, r[0]);
 308    ureg_release_temporary(shader, r[1]);
 309
 310    ureg_END(shader);
 311
 312    return ureg_create_shader_and_destroy(shader, idct->pipe);
 313 }
 314
 315 static void *
 316 create_transpose_frag_shader(struct vl_idct *idct)
 317 {
 318    struct ureg_program *shader;
 319
 320    struct ureg_src l_addr[2], r_addr[2];
 321
 322    struct ureg_dst l[2], r[2];
 323    struct ureg_dst fragment;
 324
 325    shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
 326    if (!shader)
 327       return NULL;
 328
 329    l_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0, TGSI_INTERPOLATE_LINEAR);
 330    l_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1, TGSI_INTERPOLATE_LINEAR);
 331
 332    r_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR0, TGSI_INTERPOLATE_LINEAR);
 333    r_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR1, TGSI_INTERPOLATE_LINEAR);
 334
 335    l[0] = ureg_DECL_temporary(shader);
 336    l[1] = ureg_DECL_temporary(shader);
 337    r[0] = ureg_DECL_temporary(shader);
 338    r[1] = ureg_DECL_temporary(shader);
 339
 340    fetch_four(shader, l, l_addr, ureg_DECL_sampler(shader, 0));
 341    fetch_four(shader, r, r_addr, ureg_DECL_sampler(shader, 1));
 342
 343    fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
 344
 345    matrix_mul(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X), l, r);
 346
 347    ureg_release_temporary(shader, l[0]);
 348    ureg_release_temporary(shader, l[1]);
 349    ureg_release_temporary(shader, r[0]);
 350    ureg_release_temporary(shader, r[1]);
 351
 352    ureg_END(shader);
 353
 354    return ureg_create_shader_and_destroy(shader, idct->pipe);
 355 }
 356
 357 static bool
 358 init_shaders(struct vl_idct *idct)
 359 {
 360    idct->matrix_vs = create_vert_shader(idct, true);
 361    if (!idct->matrix_vs)
 362       goto error_matrix_vs;
 363
 364    idct->matrix_fs = create_matrix_frag_shader(idct);
 365    if (!idct->matrix_fs)
 366       goto error_matrix_fs;
 367
 368    idct->transpose_vs = create_vert_shader(idct, false);
 369    if (!idct->transpose_vs)
 370       goto error_transpose_vs;
 371
 372    idct->transpose_fs = create_transpose_frag_shader(idct);
 373    if (!idct->transpose_fs)
 374       goto error_transpose_fs;
 375
 376    return true;
 377
 378 error_transpose_fs:
 379    idct->pipe->delete_vs_state(idct->pipe, idct->transpose_vs);
 380
 381 error_transpose_vs:
 382    idct->pipe->delete_fs_state(idct->pipe, idct->matrix_fs);
 383
 384 error_matrix_fs:
 385    idct->pipe->delete_vs_state(idct->pipe, idct->matrix_vs);
 386
 387 error_matrix_vs:
 388    return false;
 389 }
 390
 391 static void
 392 cleanup_shaders(struct vl_idct *idct)
 393 {
 394    idct->pipe->delete_vs_state(idct->pipe, idct->matrix_vs);
 395    idct->pipe->delete_fs_state(idct->pipe, idct->matrix_fs);
 396    idct->pipe->delete_vs_state(idct->pipe, idct->transpose_vs);
 397    idct->pipe->delete_fs_state(idct->pipe, idct->transpose_fs);
 398 }
 399
 400 static bool
 401 init_state(struct vl_idct *idct)
 402 {
 403    struct pipe_blend_state blend;
 404    struct pipe_rasterizer_state rs_state;
 405    struct pipe_sampler_state sampler;
 406    unsigned i;
 407
 408    assert(idct);
 409
 410    memset(&rs_state, 0, sizeof(rs_state));
 411    rs_state.gl_rasterization_rules = false;
 412    idct->rs_state = idct->pipe->create_rasterizer_state(idct->pipe, &rs_state);
 413    if (!idct->rs_state)
 414       goto error_rs_state;
 415
 416    memset(&blend, 0, sizeof blend);
 417
 418    blend.independent_blend_enable = 0;
 419    blend.rt[0].blend_enable = 0;
 420    blend.rt[0].rgb_func = PIPE_BLEND_ADD;
 421    blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
 422    blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
 423    blend.rt[0].alpha_func = PIPE_BLEND_ADD;
 424    blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
 425    blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
 426    blend.logicop_enable = 0;
 427    blend.logicop_func = PIPE_LOGICOP_CLEAR;
 428    /* Needed to allow color writes to FB, even if blending disabled */
 429    blend.rt[0].colormask = PIPE_MASK_RGBA;
 430    blend.dither = 0;
 431    idct->blend = idct->pipe->create_blend_state(idct->pipe, &blend);
 432    if (!idct->blend)
 433       goto error_blend;
 434
 435    for (i = 0; i < 2; ++i) {
 436       memset(&sampler, 0, sizeof(sampler));
 437       sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
 438       sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
 439       sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
 440       sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 441       sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 442       sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 443       sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
 444       sampler.compare_func = PIPE_FUNC_ALWAYS;
 445       sampler.normalized_coords = 1;
 446       idct->samplers[i] = idct->pipe->create_sampler_state(idct->pipe, &sampler);
 447       if (!idct->samplers[i])
 448          goto error_samplers;
 449    }
 450
 451    return true;
 452
 453 error_samplers:
 454    for (i = 0; i < 2; ++i)
 455       if (idct->samplers[i])
 456          idct->pipe->delete_sampler_state(idct->pipe, idct->samplers[i]);
 457
 458    idct->pipe->delete_rasterizer_state(idct->pipe, idct->rs_state);
 459
 460 error_blend:
 461    idct->pipe->delete_blend_state(idct->pipe, idct->blend);
 462
 463 error_rs_state:
 464    return false;
 465 }
 466
 467 static void
 468 cleanup_state(struct vl_idct *idct)
 469 {
 470    unsigned i;
 471
 472    for (i = 0; i < 2; ++i)
 473       idct->pipe->delete_sampler_state(idct->pipe, idct->samplers[i]);
 474
 475    idct->pipe->delete_rasterizer_state(idct->pipe, idct->rs_state);
 476    idct->pipe->delete_blend_state(idct->pipe, idct->blend);
 477 }
 478
 479 static bool
 480 init_intermediate(struct vl_idct *idct, struct vl_idct_buffer *buffer)
 481 {
 482    struct pipe_resource *tex;
 483    struct pipe_surface surf_templ;
 484    unsigned i;
 485
 486    assert(idct && buffer);
 487
 488    tex = buffer->sampler_views.individual.intermediate->texture;
 489
 490    buffer->fb_state[0].width = tex->width0;
 491    buffer->fb_state[0].height = tex->height0;
 492    buffer->fb_state[0].nr_cbufs = idct->nr_of_render_targets;
 493    for(i = 0; i < idct->nr_of_render_targets; ++i) {
 494       memset(&surf_templ, 0, sizeof(surf_templ));
 495       surf_templ.format = tex->format;
 496       surf_templ.u.tex.first_layer = i;
 497       surf_templ.u.tex.last_layer = i;
 498       surf_templ.usage = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
 499       buffer->fb_state[0].cbufs[i] = idct->pipe->create_surface(
 500          idct->pipe, tex, &surf_templ);
 501
 502       if (!buffer->fb_state[0].cbufs[i])
 503          goto error_surfaces;
 504    }
 505
 506    buffer->viewport[0].scale[0] = tex->width0;
 507    buffer->viewport[0].scale[1] = tex->height0;
 508
 509    return true;
 510
 511 error_surfaces:
 512    for(i = 0; i < idct->nr_of_render_targets; ++i)
 513       pipe_surface_reference(&buffer->fb_state[0].cbufs[i], NULL);
 514
 515    return false;
 516 }
 517
 518 static void
 519 cleanup_intermediate(struct vl_idct *idct, struct vl_idct_buffer *buffer)
 520 {
 521    unsigned i;
 522
 523    assert(idct && buffer);
 524
 525    for(i = 0; i < idct->nr_of_render_targets; ++i)
 526       pipe_surface_reference(&buffer->fb_state[0].cbufs[i], NULL);
 527
 528    pipe_sampler_view_reference(&buffer->sampler_views.individual.intermediate, NULL);
 529 }
 530
 531 struct pipe_sampler_view *
 532 vl_idct_upload_matrix(struct pipe_context *pipe, float scale)
 533 {
 534    struct pipe_resource tex_templ, *matrix;
 535    struct pipe_sampler_view sv_templ, *sv;
 536    struct pipe_transfer *buf_transfer;
 537    unsigned i, j, pitch;
 538    float *f;
 539
 540    struct pipe_box rect =
 541    {
 542       0, 0, 0,
 543       BLOCK_WIDTH / 4,
 544       BLOCK_HEIGHT,
 545       1
 546    };
 547
 548    assert(pipe);
 549
 550    memset(&tex_templ, 0, sizeof(tex_templ));
 551    tex_templ.target = PIPE_TEXTURE_2D;
 552    tex_templ.format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 553    tex_templ.last_level = 0;
 554    tex_templ.width0 = 2;
 555    tex_templ.height0 = 8;
 556    tex_templ.depth0 = 1;
 557    tex_templ.array_size = 1;
 558    tex_templ.usage = PIPE_USAGE_IMMUTABLE;
 559    tex_templ.bind = PIPE_BIND_SAMPLER_VIEW;
 560    tex_templ.flags = 0;
 561
 562    matrix = pipe->screen->resource_create(pipe->screen, &tex_templ);
 563    if (!matrix)
 564       goto error_matrix;
 565
 566    buf_transfer = pipe->get_transfer
 567    (
 568       pipe, matrix,
 569       0, PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD,
 570       &rect
 571    );
 572    if (!buf_transfer)
 573       goto error_transfer;
 574
 575    pitch = buf_transfer->stride / sizeof(float);
 576
 577    f = pipe->transfer_map(pipe, buf_transfer);
 578    if (!f)
 579       goto error_map;
 580
 581    for(i = 0; i < BLOCK_HEIGHT; ++i)
 582       for(j = 0; j < BLOCK_WIDTH; ++j)
 583          // transpose and scale
 584          f[i * pitch + j] = const_matrix[j][i] * scale;
 585
 586    pipe->transfer_unmap(pipe, buf_transfer);
 587    pipe->transfer_destroy(pipe, buf_transfer);
 588
 589    memset(&sv_templ, 0, sizeof(sv_templ));
 590    u_sampler_view_default_template(&sv_templ, matrix, matrix->format);
 591    sv = pipe->create_sampler_view(pipe, matrix, &sv_templ);
 592    pipe_resource_reference(&matrix, NULL);
 593    if (!sv)
 594       goto error_map;
 595
 596    return sv;
 597
 598 error_map:
 599    pipe->transfer_destroy(pipe, buf_transfer);
 600
 601 error_transfer:
 602    pipe_resource_reference(&matrix, NULL);
 603
 604 error_matrix:
 605    return NULL;
 606 }
 607
 608 bool vl_idct_init(struct vl_idct *idct, struct pipe_context *pipe,
 609                   unsigned buffer_width, unsigned buffer_height,
 610                   unsigned blocks_x, unsigned blocks_y,
 611                   unsigned nr_of_render_targets,
 612                   struct pipe_sampler_view *matrix,
 613                   struct pipe_sampler_view *transpose)
 614 {
 615    assert(idct && pipe && matrix);
 616
 617    idct->pipe = pipe;
 618    idct->buffer_width = buffer_width;
 619    idct->buffer_height = buffer_height;
 620    idct->blocks_x = blocks_x;
 621    idct->blocks_y = blocks_y;
 622    idct->nr_of_render_targets = nr_of_render_targets;
 623
 624    pipe_sampler_view_reference(&idct->matrix, matrix);
 625    pipe_sampler_view_reference(&idct->transpose, transpose);
 626
 627    if(!init_shaders(idct))
 628       return false;
 629
 630    if(!init_state(idct)) {
 631       cleanup_shaders(idct);
 632       return false;
 633    }
 634
 635    return true;
 636 }
 637
 638 void
 639 vl_idct_cleanup(struct vl_idct *idct)
 640 {
 641    cleanup_shaders(idct);
 642    cleanup_state(idct);
 643
 644    pipe_sampler_view_reference(&idct->matrix, NULL);
 645 }
 646
 647 bool
 648 vl_idct_init_buffer(struct vl_idct *idct, struct vl_idct_buffer *buffer,
 649                     struct pipe_sampler_view *source,
 650                     struct pipe_sampler_view *intermediate,
 651                     struct pipe_surface *destination)
 652 {
 653    unsigned i;
 654
 655    assert(buffer);
 656    assert(idct);
 657    assert(source);
 658    assert(destination);
 659
 660    pipe_sampler_view_reference(&buffer->sampler_views.individual.matrix, idct->matrix);
 661    pipe_sampler_view_reference(&buffer->sampler_views.individual.source, source);
 662    pipe_sampler_view_reference(&buffer->sampler_views.individual.transpose, idct->transpose);
 663    pipe_sampler_view_reference(&buffer->sampler_views.individual.intermediate, intermediate);
 664
 665    if (!init_intermediate(idct, buffer))
 666       return false;
 667
 668    /* init state */
 669    buffer->fb_state[1].width = destination->texture->width0;
 670    buffer->fb_state[1].height = destination->texture->height0;
 671    buffer->fb_state[1].nr_cbufs = 1;
 672    pipe_surface_reference(&buffer->fb_state[1].cbufs[0], destination);
 673
 674    buffer->viewport[1].scale[0] = destination->texture->width0;
 675    buffer->viewport[1].scale[1] = destination->texture->height0;
 676
 677    for(i = 0; i < 2; ++i) {
 678       buffer->viewport[i].scale[2] = 1;
 679       buffer->viewport[i].scale[3] = 1;
 680       buffer->viewport[i].translate[0] = 0;
 681       buffer->viewport[i].translate[1] = 0;
 682       buffer->viewport[i].translate[2] = 0;
 683       buffer->viewport[i].translate[3] = 0;
 684
 685       buffer->fb_state[i].zsbuf = NULL;
 686    }
 687
 688    return true;
 689 }
 690
 691 void
 692 vl_idct_cleanup_buffer(struct vl_idct *idct, struct vl_idct_buffer *buffer)
 693 {
 694    unsigned i;
 695
 696    assert(idct && buffer);
 697
 698    for(i = 0; i < idct->nr_of_render_targets; ++i)
 699       pipe_surface_reference(&buffer->fb_state[0].cbufs[i], NULL);
 700
 701    pipe_surface_reference(&buffer->fb_state[1].cbufs[0], NULL);
 702
 703    cleanup_intermediate(idct, buffer);
 704 }
 705
 706 void
 707 vl_idct_flush(struct vl_idct *idct, struct vl_idct_buffer *buffer, unsigned num_instances)
 708 {
 709    unsigned num_verts;
 710
 711    assert(idct);
 712    assert(buffer);
 713
 714    if(num_instances > 0) {
 715       num_verts = idct->blocks_x * idct->blocks_y * 4;
 716
 717       idct->pipe->bind_rasterizer_state(idct->pipe, idct->rs_state);
 718       idct->pipe->bind_blend_state(idct->pipe, idct->blend);
 719       idct->pipe->bind_fragment_sampler_states(idct->pipe, 2, idct->samplers);
 720
 721       /* first stage */
 722       idct->pipe->set_framebuffer_state(idct->pipe, &buffer->fb_state[0]);
 723       idct->pipe->set_viewport_state(idct->pipe, &buffer->viewport[0]);
 724       idct->pipe->set_fragment_sampler_views(idct->pipe, 2, buffer->sampler_views.stage[0]);
 725       idct->pipe->bind_vs_state(idct->pipe, idct->matrix_vs);
 726       idct->pipe->bind_fs_state(idct->pipe, idct->matrix_fs);
 727       util_draw_arrays_instanced(idct->pipe, PIPE_PRIM_QUADS, 0, num_verts, 0, num_instances);
 728
 729       /* second stage */
 730       idct->pipe->set_framebuffer_state(idct->pipe, &buffer->fb_state[1]);
 731       idct->pipe->set_viewport_state(idct->pipe, &buffer->viewport[1]);
 732       idct->pipe->set_fragment_sampler_views(idct->pipe, 2, buffer->sampler_views.stage[1]);
 733       idct->pipe->bind_vs_state(idct->pipe, idct->transpose_vs);
 734       idct->pipe->bind_fs_state(idct->pipe, idct->transpose_fs);
 735       util_draw_arrays_instanced(idct->pipe, PIPE_PRIM_QUADS, 0, num_verts, 0, num_instances);
 736    }
 737 }