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