projects / mesa.git / blob
? search:


b418aea951409728aa205f068a743e24d3bfb58d
[mesa.git] / 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 "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
47 enum 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
56 static 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
67 static void
68 calc_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
93 static void *
94 create_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
205 static void
206 increment_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
224 static void
225 fetch_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
231 static void
232 matrix_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
251 static void *
252 create_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
321 static void *
322 create_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
363 static bool
364 init_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
379 static void
380 cleanup_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
388 static bool
389 init_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
435 static void
436 cleanup_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
447 static bool
448 init_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
490 static void
491 cleanup_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
503 static bool
504 init_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
519 static void
520 cleanup_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
528 struct pipe_resource *
529 vl_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
579 bool 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
604 void
605 vl_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
613 bool
614 vl_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
682 void
683 vl_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
699 void
700 vl_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
722 void
723 vl_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
740 void
741 vl_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
749 void
750 vl_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 }