projects / mesa.git / blob
? search:


cda6dc134a05530b667af978405ac433cdee782b
[mesa.git] / src / gallium / auxiliary / vl / vl_compositor.c
1 /**************************************************************************
2 *
3 * Copyright 2009 Younes Manton.
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_compositor.h"
29 #include <assert.h>
30 #include <pipe/p_context.h>
31 #include <pipe/p_inlines.h>
32 #include <tgsi/tgsi_parse.h>
33 #include <tgsi/tgsi_build.h>
34 #include <util/u_memory.h>
35 #include "vl_csc.h"
36 #include "vl_shader_build.h"
37
38 struct vertex2f
39 {
40 float x, y;
41 };
42
43 struct vertex4f
44 {
45 float x, y, z, w;
46 };
47
48 struct vertex_shader_consts
49 {
50 struct vertex4f dst_scale;
51 struct vertex4f dst_trans;
52 struct vertex4f src_scale;
53 struct vertex4f src_trans;
54 };
55
56 struct fragment_shader_consts
57 {
58 float matrix[16];
59 };
60
61 /*
62 * Represents 2 triangles in a strip in normalized coords.
63 * Used to render the surface onto the frame buffer.
64 */
65 static const struct vertex2f surface_verts[4] =
66 {
67 {0.0f, 0.0f},
68 {0.0f, 1.0f},
69 {1.0f, 0.0f},
70 {1.0f, 1.0f}
71 };
72
73 /*
74 * Represents texcoords for the above. We can use the position values directly.
75 * TODO: Duplicate these in the shader, no need to create a buffer.
76 */
77 static const struct vertex2f *surface_texcoords = surface_verts;
78
79 static void
80 create_vert_shader(struct vl_compositor *c)
81 {
82 const unsigned max_tokens = 50;
83
84 struct pipe_shader_state vs;
85 struct tgsi_token *tokens;
86 struct tgsi_header *header;
87
88 struct tgsi_full_declaration decl;
89 struct tgsi_full_instruction inst;
90
91 unsigned ti;
92
93 unsigned i;
94
95 assert(c);
96
97 tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
98 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
99 header = (struct tgsi_header*)&tokens[1];
100 *header = tgsi_build_header();
101 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
102
103 ti = 3;
104
105 /*
106 * decl i0 ; Vertex pos
107 * decl i1 ; Vertex texcoords
108 */
109 for (i = 0; i < 2; i++) {
110 decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
111 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
112 }
113
114 /*
115 * decl c0 ; Scaling vector to scale vertex pos rect to destination size
116 * decl c1 ; Translation vector to move vertex pos rect into position
117 * decl c2 ; Scaling vector to scale texcoord rect to source size
118 * decl c3 ; Translation vector to move texcoord rect into position
119 */
120 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
121 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
122
123 /*
124 * decl o0 ; Vertex pos
125 * decl o1 ; Vertex texcoords
126 */
127 for (i = 0; i < 2; i++) {
128 decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
129 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
130 }
131
132 /* decl t0, t1 */
133 decl = vl_decl_temps(0, 1);
134 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
135
136 /*
137 * mad o0, i0, c0, c1 ; Scale and translate unit output rect to destination size and pos
138 * mad o1, i1, c2, c3 ; Scale and translate unit texcoord rect to source size and pos
139 */
140 for (i = 0; i < 2; ++i) {
141 inst = vl_inst4(TGSI_OPCODE_MAD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
142 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
143 }
144
145 /* end */
146 inst = vl_end();
147 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
148
149 assert(ti <= max_tokens);
150
151 vs.tokens = tokens;
152 c->vertex_shader = c->pipe->create_vs_state(c->pipe, &vs);
153 FREE(tokens);
154 }
155
156 static void
157 create_frag_shader(struct vl_compositor *c)
158 {
159 const unsigned max_tokens = 50;
160
161 struct pipe_shader_state fs;
162 struct tgsi_token *tokens;
163 struct tgsi_header *header;
164
165 struct tgsi_full_declaration decl;
166 struct tgsi_full_instruction inst;
167
168 unsigned ti;
169
170 unsigned i;
171
172 assert(c);
173
174 tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
175 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
176 header = (struct tgsi_header*)&tokens[1];
177 *header = tgsi_build_header();
178 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
179
180 ti = 3;
181
182 /* decl i0 ; Texcoords for s0 */
183 decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, 1, 0, 0, TGSI_INTERPOLATE_LINEAR);
184 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
185
186 /*
187 * decl c0-c3 ; CSC matrix c0-c3
188 */
189 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
190 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
191
192 /* decl o0 ; Fragment color */
193 decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
194 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
195
196 /* decl t0 */
197 decl = vl_decl_temps(0, 0);
198 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
199
200 /* decl s0 ; Sampler for tex containing picture to display */
201 decl = vl_decl_samplers(0, 0);
202 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
203
204 /* tex2d t0, i0, s0 ; Read src pixel */
205 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_SAMPLER, 0);
206 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
207
208 /*
209 * dp4 o0.x, t0, c0 ; Multiply pixel by the color conversion matrix
210 * dp4 o0.y, t0, c1
211 * dp4 o0.z, t0, c2
212 * dp4 o0.w, t0, c3
213 */
214 for (i = 0; i < 4; ++i) {
215 inst = vl_inst3(TGSI_OPCODE_DP4, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, i);
216 inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
217 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
218 }
219
220 /* end */
221 inst = vl_end();
222 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
223
224 assert(ti <= max_tokens);
225
226 fs.tokens = tokens;
227 c->fragment_shader = c->pipe->create_fs_state(c->pipe, &fs);
228 FREE(tokens);
229 }
230
231 static bool
232 init_pipe_state(struct vl_compositor *c)
233 {
234 struct pipe_sampler_state sampler;
235
236 assert(c);
237
238 c->fb_state.nr_cbufs = 1;
239 c->fb_state.zsbuf = NULL;
240
241 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
242 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
243 sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
244 sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
245 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
246 sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
247 sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
248 sampler.compare_func = PIPE_FUNC_ALWAYS;
249 sampler.normalized_coords = 1;
250 /*sampler.prefilter = ;*/
251 /*sampler.lod_bias = ;*/
252 /*sampler.min_lod = ;*/
253 /*sampler.max_lod = ;*/
254 /*sampler.border_color[i] = ;*/
255 /*sampler.max_anisotropy = ;*/
256 c->sampler = c->pipe->create_sampler_state(c->pipe, &sampler);
257
258 return true;
259 }
260
261 static void cleanup_pipe_state(struct vl_compositor *c)
262 {
263 assert(c);
264
265 c->pipe->delete_sampler_state(c->pipe, c->sampler);
266 }
267
268 static bool
269 init_shaders(struct vl_compositor *c)
270 {
271 assert(c);
272
273 create_vert_shader(c);
274 create_frag_shader(c);
275
276 return true;
277 }
278
279 static void cleanup_shaders(struct vl_compositor *c)
280 {
281 assert(c);
282
283 c->pipe->delete_vs_state(c->pipe, c->vertex_shader);
284 c->pipe->delete_fs_state(c->pipe, c->fragment_shader);
285 }
286
287 static bool
288 init_buffers(struct vl_compositor *c)
289 {
290 struct fragment_shader_consts fsc;
291
292 assert(c);
293
294 /*
295 * Create our vertex buffer and vertex buffer element
296 * VB contains 4 vertices that render a quad covering the entire window
297 * to display a rendered surface
298 * Quad is rendered as a tri strip
299 */
300 c->vertex_bufs[0].stride = sizeof(struct vertex2f);
301 c->vertex_bufs[0].max_index = 3;
302 c->vertex_bufs[0].buffer_offset = 0;
303 c->vertex_bufs[0].buffer = pipe_buffer_create
304 (
305 c->pipe->screen,
306 1,
307 PIPE_BUFFER_USAGE_VERTEX,
308 sizeof(struct vertex2f) * 4
309 );
310
311 memcpy
312 (
313 pipe_buffer_map(c->pipe->screen, c->vertex_bufs[0].buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
314 surface_verts,
315 sizeof(struct vertex2f) * 4
316 );
317
318 pipe_buffer_unmap(c->pipe->screen, c->vertex_bufs[0].buffer);
319
320 c->vertex_elems[0].src_offset = 0;
321 c->vertex_elems[0].vertex_buffer_index = 0;
322 c->vertex_elems[0].nr_components = 2;
323 c->vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
324
325 /*
326 * Create our texcoord buffer and texcoord buffer element
327 * Texcoord buffer contains the TCs for mapping the rendered surface to the 4 vertices
328 */
329 c->vertex_bufs[1].stride = sizeof(struct vertex2f);
330 c->vertex_bufs[1].max_index = 3;
331 c->vertex_bufs[1].buffer_offset = 0;
332 c->vertex_bufs[1].buffer = pipe_buffer_create
333 (
334 c->pipe->screen,
335 1,
336 PIPE_BUFFER_USAGE_VERTEX,
337 sizeof(struct vertex2f) * 4
338 );
339
340 memcpy
341 (
342 pipe_buffer_map(c->pipe->screen, c->vertex_bufs[1].buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
343 surface_texcoords,
344 sizeof(struct vertex2f) * 4
345 );
346
347 pipe_buffer_unmap(c->pipe->screen, c->vertex_bufs[1].buffer);
348
349 c->vertex_elems[1].src_offset = 0;
350 c->vertex_elems[1].vertex_buffer_index = 1;
351 c->vertex_elems[1].nr_components = 2;
352 c->vertex_elems[1].src_format = PIPE_FORMAT_R32G32_FLOAT;
353
354 /*
355 * Create our vertex shader's constant buffer
356 * Const buffer contains scaling and translation vectors
357 */
358 c->vs_const_buf.buffer = pipe_buffer_create
359 (
360 c->pipe->screen,
361 1,
362 PIPE_BUFFER_USAGE_CONSTANT | PIPE_BUFFER_USAGE_DISCARD,
363 sizeof(struct vertex_shader_consts)
364 );
365
366 /*
367 * Create our fragment shader's constant buffer
368 * Const buffer contains the color conversion matrix and bias vectors
369 */
370 c->fs_const_buf.buffer = pipe_buffer_create
371 (
372 c->pipe->screen,
373 1,
374 PIPE_BUFFER_USAGE_CONSTANT,
375 sizeof(struct fragment_shader_consts)
376 );
377
378 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, fsc.matrix);
379
380 vl_compositor_set_csc_matrix(c, fsc.matrix);
381
382 return true;
383 }
384
385 static void
386 cleanup_buffers(struct vl_compositor *c)
387 {
388 unsigned i;
389
390 assert(c);
391
392 for (i = 0; i < 2; ++i)
393 pipe_buffer_reference(&c->vertex_bufs[i].buffer, NULL);
394
395 pipe_buffer_reference(&c->vs_const_buf.buffer, NULL);
396 pipe_buffer_reference(&c->fs_const_buf.buffer, NULL);
397 }
398
399 bool vl_compositor_init(struct vl_compositor *compositor, struct pipe_context *pipe)
400 {
401 assert(compositor);
402
403 memset(compositor, 0, sizeof(struct vl_compositor));
404
405 compositor->pipe = pipe;
406
407 if (!init_pipe_state(compositor))
408 return false;
409 if (!init_shaders(compositor)) {
410 cleanup_pipe_state(compositor);
411 return false;
412 }
413 if (!init_buffers(compositor)) {
414 cleanup_shaders(compositor);
415 cleanup_pipe_state(compositor);
416 return false;
417 }
418
419 return true;
420 }
421
422 void vl_compositor_cleanup(struct vl_compositor *compositor)
423 {
424 assert(compositor);
425
426 cleanup_buffers(compositor);
427 cleanup_shaders(compositor);
428 cleanup_pipe_state(compositor);
429 }
430
431 void vl_compositor_render(struct vl_compositor *compositor,
432 /*struct pipe_texture *backround,
433 struct pipe_video_rect *backround_area,*/
434 struct pipe_texture *src_surface,
435 enum pipe_mpeg12_picture_type picture_type,
436 /*unsigned num_past_surfaces,
437 struct pipe_texture *past_surfaces,
438 unsigned num_future_surfaces,
439 struct pipe_texture *future_surfaces,*/
440 struct pipe_video_rect *src_area,
441 struct pipe_texture *dst_surface,
442 struct pipe_video_rect *dst_area,
443 /*unsigned num_layers,
444 struct pipe_texture *layers,
445 struct pipe_video_rect *layer_src_areas,
446 struct pipe_video_rect *layer_dst_areas*/
447 struct pipe_fence_handle **fence)
448 {
449 struct vertex_shader_consts *vs_consts;
450
451 assert(compositor);
452 assert(src_surface);
453 assert(src_area);
454 assert(dst_surface);
455 assert(dst_area);
456 assert(picture_type == PIPE_MPEG12_PICTURE_TYPE_FRAME);
457
458 compositor->fb_state.width = dst_surface->width[0];
459 compositor->fb_state.height = dst_surface->height[0];
460 compositor->fb_state.cbufs[0] = compositor->pipe->screen->get_tex_surface
461 (
462 compositor->pipe->screen,
463 dst_surface,
464 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE
465 );
466
467 compositor->viewport.scale[0] = compositor->fb_state.width;
468 compositor->viewport.scale[1] = compositor->fb_state.height;
469 compositor->viewport.scale[2] = 1;
470 compositor->viewport.scale[3] = 1;
471 compositor->viewport.translate[0] = 0;
472 compositor->viewport.translate[1] = 0;
473 compositor->viewport.translate[2] = 0;
474 compositor->viewport.translate[3] = 0;
475
476 compositor->scissor.maxx = compositor->fb_state.width;
477 compositor->scissor.maxy = compositor->fb_state.height;
478
479 compositor->pipe->set_framebuffer_state(compositor->pipe, &compositor->fb_state);
480 compositor->pipe->set_viewport_state(compositor->pipe, &compositor->viewport);
481 compositor->pipe->set_scissor_state(compositor->pipe, &compositor->scissor);
482 compositor->pipe->bind_sampler_states(compositor->pipe, 1, &compositor->sampler);
483 compositor->pipe->set_sampler_textures(compositor->pipe, 1, &src_surface);
484 compositor->pipe->bind_vs_state(compositor->pipe, compositor->vertex_shader);
485 compositor->pipe->bind_fs_state(compositor->pipe, compositor->fragment_shader);
486 compositor->pipe->set_vertex_buffers(compositor->pipe, 2, compositor->vertex_bufs);
487 compositor->pipe->set_vertex_elements(compositor->pipe, 2, compositor->vertex_elems);
488 compositor->pipe->set_constant_buffer(compositor->pipe, PIPE_SHADER_VERTEX, 0, &compositor->vs_const_buf);
489 compositor->pipe->set_constant_buffer(compositor->pipe, PIPE_SHADER_FRAGMENT, 0, &compositor->fs_const_buf);
490
491 vs_consts = pipe_buffer_map
492 (
493 compositor->pipe->screen,
494 compositor->vs_const_buf.buffer,
495 PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
496 );
497
498 vs_consts->dst_scale.x = dst_area->w / (float)compositor->fb_state.cbufs[0]->width;
499 vs_consts->dst_scale.y = dst_area->h / (float)compositor->fb_state.cbufs[0]->height;
500 vs_consts->dst_scale.z = 1;
501 vs_consts->dst_scale.w = 1;
502 vs_consts->dst_trans.x = dst_area->x / (float)compositor->fb_state.cbufs[0]->width;
503 vs_consts->dst_trans.y = dst_area->y / (float)compositor->fb_state.cbufs[0]->height;
504 vs_consts->dst_trans.z = 0;
505 vs_consts->dst_trans.w = 0;
506
507 vs_consts->src_scale.x = src_area->w / (float)src_surface->width[0];
508 vs_consts->src_scale.y = src_area->h / (float)src_surface->height[0];
509 vs_consts->src_scale.z = 1;
510 vs_consts->src_scale.w = 1;
511 vs_consts->src_trans.x = src_area->x / (float)src_surface->width[0];
512 vs_consts->src_trans.y = src_area->y / (float)src_surface->height[0];
513 vs_consts->src_trans.z = 0;
514 vs_consts->src_trans.w = 0;
515
516 pipe_buffer_unmap(compositor->pipe->screen, compositor->vs_const_buf.buffer);
517
518 compositor->pipe->draw_arrays(compositor->pipe, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
519 compositor->pipe->flush(compositor->pipe, PIPE_FLUSH_RENDER_CACHE, fence);
520
521 pipe_surface_reference(&compositor->fb_state.cbufs[0], NULL);
522 }
523
524 void vl_compositor_set_csc_matrix(struct vl_compositor *compositor, const float *mat)
525 {
526 assert(compositor);
527
528 memcpy
529 (
530 pipe_buffer_map(compositor->pipe->screen, compositor->fs_const_buf.buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
531 mat,
532 sizeof(struct fragment_shader_consts)
533 );
534
535 pipe_buffer_unmap(compositor->pipe->screen, compositor->fs_const_buf.buffer);
536 }