vl_idct.c revision 8330bc29dda71c41c56b3c1989334823ae8779d4
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 "vl_idct.h" 29#include "vl_vertex_buffers.h" 30#include "vl_defines.h" 31#include "util/u_draw.h" 32#include <assert.h> 33#include <pipe/p_context.h> 34#include <pipe/p_screen.h> 35#include <util/u_inlines.h> 36#include <util/u_sampler.h> 37#include <util/u_format.h> 38#include <tgsi/tgsi_ureg.h> 39#include "vl_types.h" 40 41#define SCALE_FACTOR_16_TO_9 (32768.0f / 256.0f) 42 43#define NR_RENDER_TARGETS 4 44 45enum VS_OUTPUT 46{ 47 VS_O_VPOS, 48 VS_O_L_ADDR0, 49 VS_O_L_ADDR1, 50 VS_O_R_ADDR0, 51 VS_O_R_ADDR1 52}; 53 54static const float const_matrix[8][8] = { 55 { 0.3535530f, 0.3535530f, 0.3535530f, 0.3535530f, 0.3535530f, 0.3535530f, 0.353553f, 0.3535530f }, 56 { 0.4903930f, 0.4157350f, 0.2777850f, 0.0975451f, -0.0975452f, -0.2777850f, -0.415735f, -0.4903930f }, 57 { 0.4619400f, 0.1913420f, -0.1913420f, -0.4619400f, -0.4619400f, -0.1913420f, 0.191342f, 0.4619400f }, 58 { 0.4157350f, -0.0975452f, -0.4903930f, -0.2777850f, 0.2777850f, 0.4903930f, 0.097545f, -0.4157350f }, 59 { 0.3535530f, -0.3535530f, -0.3535530f, 0.3535540f, 0.3535530f, -0.3535540f, -0.353553f, 0.3535530f }, 60 { 0.2777850f, -0.4903930f, 0.0975452f, 0.4157350f, -0.4157350f, -0.0975451f, 0.490393f, -0.2777850f }, 61 { 0.1913420f, -0.4619400f, 0.4619400f, -0.1913420f, -0.1913410f, 0.4619400f, -0.461940f, 0.1913420f }, 62 { 0.0975451f, -0.2777850f, 0.4157350f, -0.4903930f, 0.4903930f, -0.4157350f, 0.277786f, -0.0975458f } 63}; 64 65static void 66calc_addr(struct ureg_program *shader, struct ureg_dst addr[2], 67 struct ureg_src tc, struct ureg_src start, bool right_side, 68 bool transposed, float size) 69{ 70 unsigned wm_start = (right_side == transposed) ? TGSI_WRITEMASK_X : TGSI_WRITEMASK_Y; 71 unsigned sw_start = right_side ? TGSI_SWIZZLE_Y : TGSI_SWIZZLE_X; 72 73 unsigned wm_tc = (right_side == transposed) ? TGSI_WRITEMASK_Y : TGSI_WRITEMASK_X; 74 unsigned sw_tc = right_side ? TGSI_SWIZZLE_X : TGSI_SWIZZLE_Y; 75 76 /* 77 * addr[0..1].(start) = right_side ? start.x : tc.x 78 * addr[0..1].(tc) = right_side ? tc.y : start.y 79 * addr[0..1].z = tc.z 80 * addr[1].(start) += 1.0f / scale 81 */ 82 ureg_MOV(shader, ureg_writemask(addr[0], wm_start), ureg_scalar(start, sw_start)); 83 ureg_MOV(shader, ureg_writemask(addr[0], wm_tc), ureg_scalar(tc, sw_tc)); 84 ureg_MOV(shader, ureg_writemask(addr[0], TGSI_WRITEMASK_Z), tc); 85 86 ureg_ADD(shader, ureg_writemask(addr[1], wm_start), ureg_scalar(start, sw_start), ureg_imm1f(shader, 1.0f / size)); 87 ureg_MOV(shader, ureg_writemask(addr[1], wm_tc), ureg_scalar(tc, sw_tc)); 88 ureg_MOV(shader, ureg_writemask(addr[1], TGSI_WRITEMASK_Z), tc); 89} 90 91static void * 92create_vert_shader(struct vl_idct *idct, bool matrix_stage, int color_swizzle) 93{ 94 struct ureg_program *shader; 95 struct ureg_src vrect, vpos, vblock, eb[4]; 96 struct ureg_src scale, blocks_xy, t_eb; 97 struct ureg_dst t_tex, t_start; 98 struct ureg_dst o_vpos, o_l_addr[2], o_r_addr[2]; 99 unsigned label; 100 101 shader = ureg_create(TGSI_PROCESSOR_VERTEX); 102 if (!shader) 103 return NULL; 104 105 t_tex = ureg_DECL_temporary(shader); 106 t_start = ureg_DECL_temporary(shader); 107 108 vrect = ureg_DECL_vs_input(shader, VS_I_RECT); 109 vpos = ureg_DECL_vs_input(shader, VS_I_VPOS); 110 vblock = ureg_swizzle(vrect, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_W, TGSI_SWIZZLE_X, TGSI_SWIZZLE_X); 111 112 o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS); 113 114 eb[0] = ureg_DECL_vs_input(shader, VS_I_EB_0_0); 115 eb[1] = ureg_DECL_vs_input(shader, VS_I_EB_1_0); 116 eb[2] = ureg_DECL_vs_input(shader, VS_I_EB_0_1); 117 eb[3] = ureg_DECL_vs_input(shader, VS_I_EB_1_1); 118 119 o_l_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0); 120 o_l_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1); 121 122 o_r_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR0); 123 o_r_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR1); 124 125 /* 126 * scale = (BLOCK_WIDTH, BLOCK_HEIGHT) / (dst.width, dst.height) 127 * blocks_xy = (blocks_x, blocks_y) 128 * 129 * ar = vblock.y * blocks.x + vblock.x 130 * if eb[ar].(color_swizzle) 131 * o_vpos.xy = -1 132 * else 133 * t_tex = vpos * blocks_xy + vblock 134 * t_start = t_tex * scale 135 * t_tex = t_tex + vrect 136 * o_vpos.xy = t_tex * scale 137 * 138 * o_l_addr = calc_addr(...) 139 * o_r_addr = calc_addr(...) 140 * endif 141 * o_vpos.zw = vpos 142 * 143 */ 144 145 scale = ureg_imm2f(shader, 146 (float)BLOCK_WIDTH / idct->buffer_width, 147 (float)BLOCK_HEIGHT / idct->buffer_height); 148 149 blocks_xy = ureg_imm2f(shader, idct->blocks_x, idct->blocks_y); 150 151 if (idct->blocks_x > 1 || idct->blocks_y > 1) { 152 struct ureg_dst ar = ureg_DECL_address(shader); 153 154 ureg_MAD(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_X), 155 ureg_scalar(vblock, TGSI_SWIZZLE_Y), blocks_xy, vblock); 156 157 ureg_ARL(shader, ureg_writemask(ar, TGSI_WRITEMASK_X), ureg_src(t_tex)); 158 t_eb = ureg_src_indirect(eb[0], ureg_src(ar)); 159 } else { 160 t_eb = eb[0]; 161 } 162 163 ureg_IF(shader, ureg_scalar(t_eb, color_swizzle), &label); 164 165 ureg_MOV(shader, o_vpos, ureg_imm1f(shader, -1.0f)); 166 167 ureg_fixup_label(shader, label, ureg_get_instruction_number(shader)); 168 ureg_ELSE(shader, &label); 169 170 ureg_MAD(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), vpos, blocks_xy, vblock); 171 ureg_MUL(shader, ureg_writemask(t_start, TGSI_WRITEMASK_XY), ureg_src(t_tex), scale); 172 173 ureg_ADD(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), ureg_src(t_tex), vrect); 174 175 ureg_MUL(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), ureg_src(t_tex), scale); 176 ureg_MUL(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_Z), 177 ureg_scalar(vrect, TGSI_SWIZZLE_X), 178 ureg_imm1f(shader, BLOCK_WIDTH / NR_RENDER_TARGETS)); 179 180 ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_XY), ureg_src(t_tex)); 181 182 if(matrix_stage) { 183 calc_addr(shader, o_l_addr, ureg_src(t_tex), ureg_src(t_start), false, false, idct->buffer_width / 4); 184 calc_addr(shader, o_r_addr, vrect, ureg_imm1f(shader, 0.0f), true, true, BLOCK_WIDTH / 4); 185 } else { 186 calc_addr(shader, o_l_addr, vrect, ureg_imm1f(shader, 0.0f), false, false, BLOCK_WIDTH / 4); 187 calc_addr(shader, o_r_addr, ureg_src(t_tex), ureg_src(t_start), true, false, idct->buffer_height / 4); 188 } 189 190 ureg_fixup_label(shader, label, ureg_get_instruction_number(shader)); 191 ureg_ENDIF(shader); 192 193 ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_ZW), vpos); 194 195 ureg_release_temporary(shader, t_tex); 196 ureg_release_temporary(shader, t_start); 197 198 ureg_END(shader); 199 200 return ureg_create_shader_and_destroy(shader, idct->pipe); 201} 202 203static void 204increment_addr(struct ureg_program *shader, struct ureg_dst daddr[2], 205 struct ureg_src saddr[2], bool right_side, bool transposed, 206 int pos, float size) 207{ 208 unsigned wm_start = (right_side == transposed) ? TGSI_WRITEMASK_X : TGSI_WRITEMASK_Y; 209 unsigned wm_tc = (right_side == transposed) ? TGSI_WRITEMASK_Y : TGSI_WRITEMASK_X; 210 211 /* 212 * daddr[0..1].(start) = saddr[0..1].(start) 213 * daddr[0..1].(tc) = saddr[0..1].(tc) 214 */ 215 216 ureg_MOV(shader, ureg_writemask(daddr[0], wm_start), saddr[0]); 217 ureg_ADD(shader, ureg_writemask(daddr[0], wm_tc), saddr[0], ureg_imm1f(shader, pos / size)); 218 ureg_MOV(shader, ureg_writemask(daddr[1], wm_start), saddr[1]); 219 ureg_ADD(shader, ureg_writemask(daddr[1], wm_tc), saddr[1], ureg_imm1f(shader, pos / size)); 220} 221 222static void 223fetch_four(struct ureg_program *shader, struct ureg_dst m[2], struct ureg_src addr[2], struct ureg_src sampler) 224{ 225 ureg_TEX(shader, m[0], TGSI_TEXTURE_3D, addr[0], sampler); 226 ureg_TEX(shader, m[1], TGSI_TEXTURE_3D, addr[1], sampler); 227} 228 229static void 230matrix_mul(struct ureg_program *shader, struct ureg_dst dst, struct ureg_dst l[2], struct ureg_dst r[2]) 231{ 232 struct ureg_dst tmp; 233 234 tmp = ureg_DECL_temporary(shader); 235 236 /* 237 * tmp.xy = dot4(m[0][0..1], m[1][0..1]) 238 * dst = tmp.x + tmp.y 239 */ 240 ureg_DP4(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X), ureg_src(l[0]), ureg_src(r[0])); 241 ureg_DP4(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y), ureg_src(l[1]), ureg_src(r[1])); 242 ureg_ADD(shader, dst, 243 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), 244 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y)); 245 246 ureg_release_temporary(shader, tmp); 247} 248 249static void * 250create_matrix_frag_shader(struct vl_idct *idct) 251{ 252 struct ureg_program *shader; 253 254 struct ureg_src l_addr[2], r_addr[2]; 255 256 struct ureg_dst l[4][2], r[2]; 257 struct ureg_dst fragment[NR_RENDER_TARGETS]; 258 259 unsigned i, j; 260 261 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT); 262 if (!shader) 263 return NULL; 264 265 l_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0, TGSI_INTERPOLATE_LINEAR); 266 l_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1, TGSI_INTERPOLATE_LINEAR); 267 268 r_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR0, TGSI_INTERPOLATE_LINEAR); 269 r_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR1, TGSI_INTERPOLATE_LINEAR); 270 271 for (i = 0; i < NR_RENDER_TARGETS; ++i) 272 fragment[i] = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, i); 273 274 for (i = 0; i < 4; ++i) { 275 l[i][0] = ureg_DECL_temporary(shader); 276 l[i][1] = ureg_DECL_temporary(shader); 277 } 278 279 r[0] = ureg_DECL_temporary(shader); 280 r[1] = ureg_DECL_temporary(shader); 281 282 for (i = 1; i < 4; ++i) { 283 increment_addr(shader, l[i], l_addr, false, false, i, idct->buffer_height); 284 } 285 286 for (i = 0; i < 4; ++i) { 287 struct ureg_src s_addr[2]; 288 s_addr[0] = i == 0 ? l_addr[0] : ureg_src(l[i][0]); 289 s_addr[1] = i == 0 ? l_addr[1] : ureg_src(l[i][1]); 290 fetch_four(shader, l[i], s_addr, ureg_DECL_sampler(shader, 1)); 291 } 292 293 for (i = 0; i < NR_RENDER_TARGETS; ++i) { 294 if(i > 0) 295 increment_addr(shader, r, r_addr, true, true, i, BLOCK_HEIGHT); 296 297 struct ureg_src s_addr[2] = { ureg_src(r[0]), ureg_src(r[1]) }; 298 s_addr[0] = i == 0 ? r_addr[0] : ureg_src(r[0]); 299 s_addr[1] = i == 0 ? r_addr[1] : ureg_src(r[1]); 300 fetch_four(shader, r, s_addr, ureg_DECL_sampler(shader, 0)); 301 302 for (j = 0; j < 4; ++j) { 303 matrix_mul(shader, ureg_writemask(fragment[i], TGSI_WRITEMASK_X << j), l[j], r); 304 } 305 } 306 307 for (i = 0; i < 4; ++i) { 308 ureg_release_temporary(shader, l[i][0]); 309 ureg_release_temporary(shader, l[i][1]); 310 } 311 ureg_release_temporary(shader, r[0]); 312 ureg_release_temporary(shader, r[1]); 313 314 ureg_END(shader); 315 316 return ureg_create_shader_and_destroy(shader, idct->pipe); 317} 318 319static void * 320create_transpose_frag_shader(struct vl_idct *idct) 321{ 322 struct ureg_program *shader; 323 324 struct ureg_src l_addr[2], r_addr[2]; 325 326 struct ureg_dst l[2], r[2]; 327 struct ureg_dst fragment; 328 329 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT); 330 if (!shader) 331 return NULL; 332 333 l_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0, TGSI_INTERPOLATE_LINEAR); 334 l_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1, TGSI_INTERPOLATE_LINEAR); 335 336 r_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR0, TGSI_INTERPOLATE_LINEAR); 337 r_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_R_ADDR1, TGSI_INTERPOLATE_LINEAR); 338 339 l[0] = ureg_DECL_temporary(shader); 340 l[1] = ureg_DECL_temporary(shader); 341 r[0] = ureg_DECL_temporary(shader); 342 r[1] = ureg_DECL_temporary(shader); 343 344 fetch_four(shader, l, l_addr, ureg_DECL_sampler(shader, 0)); 345 fetch_four(shader, r, r_addr, ureg_DECL_sampler(shader, 1)); 346 347 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0); 348 349 matrix_mul(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X), l, r); 350 351 ureg_release_temporary(shader, l[0]); 352 ureg_release_temporary(shader, l[1]); 353 ureg_release_temporary(shader, r[0]); 354 ureg_release_temporary(shader, r[1]); 355 356 ureg_END(shader); 357 358 return ureg_create_shader_and_destroy(shader, idct->pipe); 359} 360 361static bool 362init_shaders(struct vl_idct *idct, int color_swizzle) 363{ 364 idct->matrix_vs = create_vert_shader(idct, true, color_swizzle); 365 if (!idct->matrix_vs) 366 goto error_matrix_vs; 367 368 idct->matrix_fs = create_matrix_frag_shader(idct); 369 if (!idct->matrix_fs) 370 goto error_matrix_fs; 371 372 idct->transpose_vs = create_vert_shader(idct, false, color_swizzle); 373 if (!idct->transpose_vs) 374 goto error_transpose_vs; 375 376 idct->transpose_fs = create_transpose_frag_shader(idct); 377 if (!idct->transpose_fs) 378 goto error_transpose_fs; 379 380 return true; 381 382error_transpose_fs: 383 idct->pipe->delete_vs_state(idct->pipe, idct->transpose_vs); 384 385error_transpose_vs: 386 idct->pipe->delete_fs_state(idct->pipe, idct->matrix_fs); 387 388error_matrix_fs: 389 idct->pipe->delete_vs_state(idct->pipe, idct->matrix_vs); 390 391error_matrix_vs: 392 return false; 393} 394 395static void 396cleanup_shaders(struct vl_idct *idct) 397{ 398 idct->pipe->delete_vs_state(idct->pipe, idct->matrix_vs); 399 idct->pipe->delete_fs_state(idct->pipe, idct->matrix_fs); 400 idct->pipe->delete_vs_state(idct->pipe, idct->transpose_vs); 401 idct->pipe->delete_fs_state(idct->pipe, idct->transpose_fs); 402} 403 404static bool 405init_state(struct vl_idct *idct) 406{ 407 struct pipe_sampler_state sampler; 408 struct pipe_rasterizer_state rs_state; 409 unsigned i; 410 411 assert(idct); 412 413 memset(&rs_state, 0, sizeof(rs_state)); 414 rs_state.gl_rasterization_rules = false; 415 idct->rs_state = idct->pipe->create_rasterizer_state(idct->pipe, &rs_state); 416 if (!idct->rs_state) 417 goto error_rs_state; 418 419 for (i = 0; i < 4; ++i) { 420 memset(&sampler, 0, sizeof(sampler)); 421 sampler.wrap_s = PIPE_TEX_WRAP_REPEAT; 422 sampler.wrap_t = PIPE_TEX_WRAP_REPEAT; 423 sampler.wrap_r = PIPE_TEX_WRAP_REPEAT; 424 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST; 425 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE; 426 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST; 427 sampler.compare_mode = PIPE_TEX_COMPARE_NONE; 428 sampler.compare_func = PIPE_FUNC_ALWAYS; 429 sampler.normalized_coords = 1; 430 idct->samplers.all[i] = idct->pipe->create_sampler_state(idct->pipe, &sampler); 431 if (!idct->samplers.all[i]) 432 goto error_samplers; 433 } 434 435 return true; 436 437error_samplers: 438 for (i = 0; i < 4; ++i) 439 if (idct->samplers.all[i]) 440 idct->pipe->delete_sampler_state(idct->pipe, idct->samplers.all[i]); 441 442 idct->pipe->delete_rasterizer_state(idct->pipe, idct->rs_state); 443 444error_rs_state: 445 return false; 446} 447 448static void 449cleanup_state(struct vl_idct *idct) 450{ 451 unsigned i; 452 453 for (i = 0; i < 4; ++i) 454 idct->pipe->delete_sampler_state(idct->pipe, idct->samplers.all[i]); 455 456 idct->pipe->delete_rasterizer_state(idct->pipe, idct->rs_state); 457} 458 459static bool 460init_textures(struct vl_idct *idct, struct vl_idct_buffer *buffer) 461{ 462 struct pipe_resource template; 463 struct pipe_sampler_view sampler_view; 464 unsigned i; 465 466 assert(idct && buffer); 467 468 /* create textures */ 469 memset(&template, 0, sizeof(struct pipe_resource)); 470 template.last_level = 0; 471 template.bind = PIPE_BIND_SAMPLER_VIEW; 472 template.flags = 0; 473 474 template.target = PIPE_TEXTURE_2D; 475 template.format = PIPE_FORMAT_R16G16B16A16_SNORM; 476 template.width0 = idct->buffer_width / 4; 477 template.height0 = idct->buffer_height; 478 template.depth0 = 1; 479 template.array_size = 1; 480 template.usage = PIPE_USAGE_STREAM; 481 buffer->textures.individual.source = idct->pipe->screen->resource_create(idct->pipe->screen, &template); 482 if (!buffer->textures.individual.source) 483 goto error; 484 485 template.target = PIPE_TEXTURE_3D; 486 template.format = PIPE_FORMAT_R16G16B16A16_SNORM; 487 template.width0 = idct->buffer_width / NR_RENDER_TARGETS; 488 template.height0 = idct->buffer_height / 4; 489 template.depth0 = NR_RENDER_TARGETS; 490 template.usage = PIPE_USAGE_STATIC; 491 buffer->textures.individual.intermediate = idct->pipe->screen->resource_create(idct->pipe->screen, &template); 492 if (!buffer->textures.individual.intermediate) 493 goto error; 494 495 for (i = 0; i < 4; ++i) { 496 memset(&sampler_view, 0, sizeof(sampler_view)); 497 u_sampler_view_default_template(&sampler_view, buffer->textures.all[i], buffer->textures.all[i]->format); 498 buffer->sampler_views.all[i] = idct->pipe->create_sampler_view(idct->pipe, buffer->textures.all[i], &sampler_view); 499 if (!buffer->sampler_views.all[i]) 500 goto error; 501 } 502 503 template.target = PIPE_TEXTURE_2D; 504 /* TODO: Accomodate HW that can't do this and also for cases when this isn't precise enough */ 505 template.format = PIPE_FORMAT_R16_SNORM; 506 template.width0 = idct->buffer_width; 507 template.height0 = idct->buffer_height; 508 template.depth0 = 1; 509 510 buffer->destination = idct->pipe->screen->resource_create(idct->pipe->screen, &template); 511 if (!buffer->destination) 512 goto error; 513 514 return true; 515 516error: 517 for (i = 0; i < 4; ++i) { 518 pipe_sampler_view_reference(&buffer->sampler_views.all[i], NULL); 519 pipe_resource_reference(&buffer->textures.all[i], NULL); 520 } 521 return false; 522} 523 524static void 525cleanup_textures(struct vl_idct *idct, struct vl_idct_buffer *buffer) 526{ 527 unsigned i; 528 529 assert(idct && buffer); 530 531 for (i = 0; i < 4; ++i) { 532 pipe_sampler_view_reference(&buffer->sampler_views.all[i], NULL); 533 pipe_resource_reference(&buffer->textures.all[i], NULL); 534 } 535} 536 537struct pipe_resource * 538vl_idct_upload_matrix(struct pipe_context *pipe) 539{ 540 const float scale = sqrtf(SCALE_FACTOR_16_TO_9); 541 542 struct pipe_resource template, *matrix; 543 struct pipe_transfer *buf_transfer; 544 unsigned i, j, pitch; 545 float *f; 546 547 struct pipe_box rect = 548 { 549 0, 0, 0, 550 BLOCK_WIDTH / 4, 551 BLOCK_HEIGHT, 552 1 553 }; 554 555 assert(pipe); 556 557 memset(&template, 0, sizeof(struct pipe_resource)); 558 template.target = PIPE_TEXTURE_2D; 559 template.format = PIPE_FORMAT_R32G32B32A32_FLOAT; 560 template.last_level = 0; 561 template.width0 = 2; 562 template.height0 = 8; 563 template.depth0 = 1; 564 template.array_size = 1; 565 template.usage = PIPE_USAGE_IMMUTABLE; 566 template.bind = PIPE_BIND_SAMPLER_VIEW; 567 template.flags = 0; 568 569 matrix = pipe->screen->resource_create(pipe->screen, &template); 570 if (!matrix) 571 goto error_matrix; 572 573 buf_transfer = pipe->get_transfer 574 ( 575 pipe, matrix, 576 0, PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD, 577 &rect 578 ); 579 if (!buf_transfer) 580 goto error_transfer; 581 582 pitch = buf_transfer->stride / sizeof(float); 583 584 f = pipe->transfer_map(pipe, buf_transfer); 585 if (!f) 586 goto error_map; 587 588 for(i = 0; i < BLOCK_HEIGHT; ++i) 589 for(j = 0; j < BLOCK_WIDTH; ++j) 590 // transpose and scale 591 f[i * pitch + j] = const_matrix[j][i] * scale; 592 593 pipe->transfer_unmap(pipe, buf_transfer); 594 pipe->transfer_destroy(pipe, buf_transfer); 595 596 return matrix; 597 598error_map: 599 pipe->transfer_destroy(pipe, buf_transfer); 600 601error_transfer: 602 pipe_resource_reference(&matrix, NULL); 603 604error_matrix: 605 return NULL; 606} 607 608bool 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 int color_swizzle, struct pipe_resource *matrix) 612{ 613 assert(idct && pipe && matrix); 614 615 idct->pipe = pipe; 616 idct->buffer_width = buffer_width; 617 idct->buffer_height = buffer_height; 618 idct->blocks_x = blocks_x; 619 idct->blocks_y = blocks_y; 620 pipe_resource_reference(&idct->matrix, matrix); 621 622 if(!init_shaders(idct, color_swizzle)) 623 return false; 624 625 if(!init_state(idct)) { 626 cleanup_shaders(idct); 627 return false; 628 } 629 630 return true; 631} 632 633void 634vl_idct_cleanup(struct vl_idct *idct) 635{ 636 cleanup_shaders(idct); 637 cleanup_state(idct); 638 639 pipe_resource_reference(&idct->matrix, NULL); 640} 641 642struct pipe_resource * 643vl_idct_init_buffer(struct vl_idct *idct, struct vl_idct_buffer *buffer) 644{ 645 struct pipe_surface template; 646 647 unsigned i; 648 649 assert(buffer); 650 assert(idct); 651 652 pipe_resource_reference(&buffer->textures.individual.matrix, idct->matrix); 653 pipe_resource_reference(&buffer->textures.individual.transpose, idct->matrix); 654 655 if (!init_textures(idct, buffer)) 656 goto error_textures; 657 658 /* init state */ 659 buffer->viewport[0].scale[0] = buffer->textures.individual.intermediate->width0; 660 buffer->viewport[0].scale[1] = buffer->textures.individual.intermediate->height0; 661 662 buffer->viewport[1].scale[0] = buffer->destination->width0; 663 buffer->viewport[1].scale[1] = buffer->destination->height0; 664 665 buffer->fb_state[0].width = buffer->textures.individual.intermediate->width0; 666 buffer->fb_state[0].height = buffer->textures.individual.intermediate->height0; 667 668 buffer->fb_state[0].nr_cbufs = NR_RENDER_TARGETS; 669 for(i = 0; i < NR_RENDER_TARGETS; ++i) { 670 memset(&template, 0, sizeof(template)); 671 template.format = buffer->textures.individual.intermediate->format; 672 template.u.tex.first_layer = i; 673 template.u.tex.last_layer = i; 674 template.usage = PIPE_BIND_RENDER_TARGET; 675 buffer->fb_state[0].cbufs[i] = idct->pipe->create_surface( 676 idct->pipe, buffer->textures.individual.intermediate, 677 &template); 678 679 if (!buffer->fb_state[0].cbufs[i]) 680 goto error_matrix_surfaces; 681 } 682 683 buffer->fb_state[1].width = buffer->destination->width0; 684 buffer->fb_state[1].height = buffer->destination->height0; 685 686 buffer->fb_state[1].nr_cbufs = 1; 687 688 memset(&template, 0, sizeof(template)); 689 template.format = buffer->destination->format; 690 template.usage = PIPE_BIND_RENDER_TARGET; 691 buffer->fb_state[1].cbufs[0] = idct->pipe->create_surface( 692 idct->pipe, buffer->destination, &template); 693 694 if (!buffer->fb_state[1].cbufs[0]) 695 goto error_transpose_surface; 696 697 for(i = 0; i < 2; ++i) { 698 buffer->viewport[i].scale[2] = 1; 699 buffer->viewport[i].scale[3] = 1; 700 buffer->viewport[i].translate[0] = 0; 701 buffer->viewport[i].translate[1] = 0; 702 buffer->viewport[i].translate[2] = 0; 703 buffer->viewport[i].translate[3] = 0; 704 705 buffer->fb_state[i].zsbuf = NULL; 706 } 707 708 return buffer->destination; 709 710error_transpose_surface: 711 pipe_surface_reference(&buffer->fb_state[1].cbufs[0], NULL); 712 713error_matrix_surfaces: 714 for(i = 0; i < NR_RENDER_TARGETS; ++i) 715 pipe_surface_reference(&buffer->fb_state[0].cbufs[i], NULL); 716 717error_textures: 718 return NULL; 719} 720 721void 722vl_idct_cleanup_buffer(struct vl_idct *idct, struct vl_idct_buffer *buffer) 723{ 724 unsigned i; 725 726 assert(idct && buffer); 727 728 for(i = 0; i < NR_RENDER_TARGETS; ++i) 729 pipe_surface_reference(&buffer->fb_state[0].cbufs[i], NULL); 730 731 pipe_surface_reference(&buffer->fb_state[1].cbufs[0], NULL); 732 733 cleanup_textures(idct, buffer); 734} 735 736void 737vl_idct_map_buffers(struct vl_idct *idct, struct vl_idct_buffer *buffer) 738{ 739 assert(idct && buffer); 740 741 struct pipe_box rect = 742 { 743 0, 0, 0, 744 buffer->textures.individual.source->width0, 745 buffer->textures.individual.source->height0, 746 1 747 }; 748 749 buffer->tex_transfer = idct->pipe->get_transfer 750 ( 751 idct->pipe, buffer->textures.individual.source, 752 0, PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD, 753 &rect 754 ); 755 756 buffer->texels = idct->pipe->transfer_map(idct->pipe, buffer->tex_transfer); 757} 758 759void 760vl_idct_add_block(struct vl_idct_buffer *buffer, unsigned x, unsigned y, short *block) 761{ 762 unsigned tex_pitch; 763 short *texels; 764 765 unsigned i; 766 767 assert(buffer); 768 assert(block); 769 770 tex_pitch = buffer->tex_transfer->stride / sizeof(short); 771 texels = buffer->texels + y * tex_pitch * BLOCK_HEIGHT + x * BLOCK_WIDTH; 772 773 for (i = 0; i < BLOCK_HEIGHT; ++i) 774 memcpy(texels + i * tex_pitch, block + i * BLOCK_WIDTH, BLOCK_WIDTH * sizeof(short)); 775} 776 777void 778vl_idct_unmap_buffers(struct vl_idct *idct, struct vl_idct_buffer *buffer) 779{ 780 assert(idct && buffer); 781 782 idct->pipe->transfer_unmap(idct->pipe, buffer->tex_transfer); 783 idct->pipe->transfer_destroy(idct->pipe, buffer->tex_transfer); 784} 785 786void 787vl_idct_flush(struct vl_idct *idct, struct vl_idct_buffer *buffer, unsigned num_instances) 788{ 789 unsigned num_verts; 790 791 assert(idct); 792 assert(buffer); 793 794 if(num_instances > 0) { 795 num_verts = idct->blocks_x * idct->blocks_y * 4; 796 797 idct->pipe->bind_rasterizer_state(idct->pipe, idct->rs_state); 798 799 /* first stage */ 800 idct->pipe->set_framebuffer_state(idct->pipe, &buffer->fb_state[0]); 801 idct->pipe->set_viewport_state(idct->pipe, &buffer->viewport[0]); 802 idct->pipe->set_fragment_sampler_views(idct->pipe, 2, buffer->sampler_views.stage[0]); 803 idct->pipe->bind_fragment_sampler_states(idct->pipe, 2, idct->samplers.stage[0]); 804 idct->pipe->bind_vs_state(idct->pipe, idct->matrix_vs); 805 idct->pipe->bind_fs_state(idct->pipe, idct->matrix_fs); 806 util_draw_arrays_instanced(idct->pipe, PIPE_PRIM_QUADS, 0, num_verts, 0, num_instances); 807 808 /* second stage */ 809 idct->pipe->set_framebuffer_state(idct->pipe, &buffer->fb_state[1]); 810 idct->pipe->set_viewport_state(idct->pipe, &buffer->viewport[1]); 811 idct->pipe->set_fragment_sampler_views(idct->pipe, 2, buffer->sampler_views.stage[1]); 812 idct->pipe->bind_fragment_sampler_states(idct->pipe, 2, idct->samplers.stage[1]); 813 idct->pipe->bind_vs_state(idct->pipe, idct->transpose_vs); 814 idct->pipe->bind_fs_state(idct->pipe, idct->transpose_fs); 815 util_draw_arrays_instanced(idct->pipe, PIPE_PRIM_QUADS, 0, num_verts, 0, num_instances); 816 } 817} 818