1 /**************************************************************************
3 * Copyright 2009 Younes Manton.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
28 #include "vl_compositor.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>
36 #include "vl_shader_build.h"
48 struct vertex_shader_consts
50 struct vertex4f dst_scale
;
51 struct vertex4f dst_trans
;
52 struct vertex4f src_scale
;
53 struct vertex4f src_trans
;
56 struct fragment_shader_consts
62 * Represents 2 triangles in a strip in normalized coords.
63 * Used to render the surface onto the frame buffer.
65 static const struct vertex2f surface_verts
[4] =
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.
77 static const struct vertex2f
*surface_texcoords
= surface_verts
;
80 create_vert_shader(struct vl_compositor
*c
)
82 const unsigned max_tokens
= 50;
84 struct pipe_shader_state vs
;
85 struct tgsi_token
*tokens
;
86 struct tgsi_header
*header
;
88 struct tgsi_full_declaration decl
;
89 struct tgsi_full_instruction inst
;
97 tokens
= (struct tgsi_token
*)MALLOC(max_tokens
* sizeof(struct tgsi_token
));
98 header
= (struct tgsi_header
*)&tokens
[0];
99 *header
= tgsi_build_header();
100 *(struct tgsi_processor
*)&tokens
[1] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX
, header
);
105 * decl i0 ; Vertex pos
106 * decl i1 ; Vertex texcoords
108 for (i
= 0; i
< 2; i
++) {
109 decl
= vl_decl_input(i
== 0 ? TGSI_SEMANTIC_POSITION
: TGSI_SEMANTIC_GENERIC
, i
, i
, i
);
110 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
114 * decl c0 ; Scaling vector to scale vertex pos rect to destination size
115 * decl c1 ; Translation vector to move vertex pos rect into position
116 * decl c2 ; Scaling vector to scale texcoord rect to source size
117 * decl c3 ; Translation vector to move texcoord rect into position
119 decl
= vl_decl_constants(TGSI_SEMANTIC_GENERIC
, 0, 0, 3);
120 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
123 * decl o0 ; Vertex pos
124 * decl o1 ; Vertex texcoords
126 for (i
= 0; i
< 2; i
++) {
127 decl
= vl_decl_output(i
== 0 ? TGSI_SEMANTIC_POSITION
: TGSI_SEMANTIC_GENERIC
, i
, i
, i
);
128 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
132 decl
= vl_decl_temps(0, 1);
133 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
136 * mad o0, i0, c0, c1 ; Scale and translate unit output rect to destination size and pos
137 * mad o1, i1, c2, c3 ; Scale and translate unit texcoord rect to source size and pos
139 for (i
= 0; i
< 2; ++i
) {
140 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);
141 ti
+= tgsi_build_full_instruction(&inst
, &tokens
[ti
], header
, max_tokens
- ti
);
146 ti
+= tgsi_build_full_instruction(&inst
, &tokens
[ti
], header
, max_tokens
- ti
);
148 assert(ti
<= max_tokens
);
151 c
->vertex_shader
= c
->pipe
->create_vs_state(c
->pipe
, &vs
);
156 create_frag_shader(struct vl_compositor
*c
)
158 const unsigned max_tokens
= 50;
160 struct pipe_shader_state fs
;
161 struct tgsi_token
*tokens
;
162 struct tgsi_header
*header
;
164 struct tgsi_full_declaration decl
;
165 struct tgsi_full_instruction inst
;
173 tokens
= (struct tgsi_token
*)MALLOC(max_tokens
* sizeof(struct tgsi_token
));
174 header
= (struct tgsi_header
*)&tokens
[0];
175 *header
= tgsi_build_header();
176 *(struct tgsi_processor
*)&tokens
[1] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT
, header
);
180 /* decl i0 ; Texcoords for s0 */
181 decl
= vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC
, 1, 0, 0, TGSI_INTERPOLATE_LINEAR
);
182 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
185 * decl c0-c3 ; CSC matrix c0-c3
187 decl
= vl_decl_constants(TGSI_SEMANTIC_GENERIC
, 0, 0, 3);
188 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
190 /* decl o0 ; Fragment color */
191 decl
= vl_decl_output(TGSI_SEMANTIC_COLOR
, 0, 0, 0);
192 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
195 decl
= vl_decl_temps(0, 0);
196 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
198 /* decl s0 ; Sampler for tex containing picture to display */
199 decl
= vl_decl_samplers(0, 0);
200 ti
+= tgsi_build_full_declaration(&decl
, &tokens
[ti
], header
, max_tokens
- ti
);
202 /* tex2d t0, i0, s0 ; Read src pixel */
203 inst
= vl_tex(TGSI_TEXTURE_2D
, TGSI_FILE_TEMPORARY
, 0, TGSI_FILE_INPUT
, 0, TGSI_FILE_SAMPLER
, 0);
204 ti
+= tgsi_build_full_instruction(&inst
, &tokens
[ti
], header
, max_tokens
- ti
);
207 * dp4 o0.x, t0, c0 ; Multiply pixel by the color conversion matrix
212 for (i
= 0; i
< 4; ++i
) {
213 inst
= vl_inst3(TGSI_OPCODE_DP4
, TGSI_FILE_OUTPUT
, 0, TGSI_FILE_TEMPORARY
, 0, TGSI_FILE_CONSTANT
, i
);
214 inst
.Dst
[0].Register
.WriteMask
= TGSI_WRITEMASK_X
<< i
;
215 ti
+= tgsi_build_full_instruction(&inst
, &tokens
[ti
], header
, max_tokens
- ti
);
220 ti
+= tgsi_build_full_instruction(&inst
, &tokens
[ti
], header
, max_tokens
- ti
);
222 assert(ti
<= max_tokens
);
225 c
->fragment_shader
= c
->pipe
->create_fs_state(c
->pipe
, &fs
);
230 init_pipe_state(struct vl_compositor
*c
)
232 struct pipe_sampler_state sampler
;
236 c
->fb_state
.nr_cbufs
= 1;
237 c
->fb_state
.zsbuf
= NULL
;
239 sampler
.wrap_s
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
240 sampler
.wrap_t
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
241 sampler
.wrap_r
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
242 sampler
.min_img_filter
= PIPE_TEX_FILTER_LINEAR
;
243 sampler
.min_mip_filter
= PIPE_TEX_MIPFILTER_NONE
;
244 sampler
.mag_img_filter
= PIPE_TEX_FILTER_LINEAR
;
245 sampler
.compare_mode
= PIPE_TEX_COMPARE_NONE
;
246 sampler
.compare_func
= PIPE_FUNC_ALWAYS
;
247 sampler
.normalized_coords
= 1;
248 /*sampler.prefilter = ;*/
249 /*sampler.lod_bias = ;*/
250 /*sampler.min_lod = ;*/
251 /*sampler.max_lod = ;*/
252 /*sampler.border_color[i] = ;*/
253 /*sampler.max_anisotropy = ;*/
254 c
->sampler
= c
->pipe
->create_sampler_state(c
->pipe
, &sampler
);
259 static void cleanup_pipe_state(struct vl_compositor
*c
)
263 c
->pipe
->delete_sampler_state(c
->pipe
, c
->sampler
);
267 init_shaders(struct vl_compositor
*c
)
271 create_vert_shader(c
);
272 create_frag_shader(c
);
277 static void cleanup_shaders(struct vl_compositor
*c
)
281 c
->pipe
->delete_vs_state(c
->pipe
, c
->vertex_shader
);
282 c
->pipe
->delete_fs_state(c
->pipe
, c
->fragment_shader
);
286 init_buffers(struct vl_compositor
*c
)
288 struct fragment_shader_consts fsc
;
293 * Create our vertex buffer and vertex buffer element
294 * VB contains 4 vertices that render a quad covering the entire window
295 * to display a rendered surface
296 * Quad is rendered as a tri strip
298 c
->vertex_bufs
[0].stride
= sizeof(struct vertex2f
);
299 c
->vertex_bufs
[0].max_index
= 3;
300 c
->vertex_bufs
[0].buffer_offset
= 0;
301 c
->vertex_bufs
[0].buffer
= pipe_buffer_create
305 PIPE_BUFFER_USAGE_VERTEX
,
306 sizeof(struct vertex2f
) * 4
311 pipe_buffer_map(c
->pipe
->screen
, c
->vertex_bufs
[0].buffer
, PIPE_BUFFER_USAGE_CPU_WRITE
),
313 sizeof(struct vertex2f
) * 4
316 pipe_buffer_unmap(c
->pipe
->screen
, c
->vertex_bufs
[0].buffer
);
318 c
->vertex_elems
[0].src_offset
= 0;
319 c
->vertex_elems
[0].vertex_buffer_index
= 0;
320 c
->vertex_elems
[0].nr_components
= 2;
321 c
->vertex_elems
[0].src_format
= PIPE_FORMAT_R32G32_FLOAT
;
324 * Create our texcoord buffer and texcoord buffer element
325 * Texcoord buffer contains the TCs for mapping the rendered surface to the 4 vertices
327 c
->vertex_bufs
[1].stride
= sizeof(struct vertex2f
);
328 c
->vertex_bufs
[1].max_index
= 3;
329 c
->vertex_bufs
[1].buffer_offset
= 0;
330 c
->vertex_bufs
[1].buffer
= pipe_buffer_create
334 PIPE_BUFFER_USAGE_VERTEX
,
335 sizeof(struct vertex2f
) * 4
340 pipe_buffer_map(c
->pipe
->screen
, c
->vertex_bufs
[1].buffer
, PIPE_BUFFER_USAGE_CPU_WRITE
),
342 sizeof(struct vertex2f
) * 4
345 pipe_buffer_unmap(c
->pipe
->screen
, c
->vertex_bufs
[1].buffer
);
347 c
->vertex_elems
[1].src_offset
= 0;
348 c
->vertex_elems
[1].vertex_buffer_index
= 1;
349 c
->vertex_elems
[1].nr_components
= 2;
350 c
->vertex_elems
[1].src_format
= PIPE_FORMAT_R32G32_FLOAT
;
353 * Create our vertex shader's constant buffer
354 * Const buffer contains scaling and translation vectors
356 c
->vs_const_buf
= pipe_buffer_create
360 PIPE_BUFFER_USAGE_CONSTANT
| PIPE_BUFFER_USAGE_DISCARD
,
361 sizeof(struct vertex_shader_consts
)
365 * Create our fragment shader's constant buffer
366 * Const buffer contains the color conversion matrix and bias vectors
368 c
->fs_const_buf
= pipe_buffer_create
372 PIPE_BUFFER_USAGE_CONSTANT
,
373 sizeof(struct fragment_shader_consts
)
376 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY
, NULL
, true, fsc
.matrix
);
378 vl_compositor_set_csc_matrix(c
, fsc
.matrix
);
384 cleanup_buffers(struct vl_compositor
*c
)
390 for (i
= 0; i
< 2; ++i
)
391 pipe_buffer_reference(&c
->vertex_bufs
[i
].buffer
, NULL
);
393 pipe_buffer_reference(&c
->vs_const_buf
, NULL
);
394 pipe_buffer_reference(&c
->fs_const_buf
, NULL
);
397 bool vl_compositor_init(struct vl_compositor
*compositor
, struct pipe_context
*pipe
)
401 memset(compositor
, 0, sizeof(struct vl_compositor
));
403 compositor
->pipe
= pipe
;
405 if (!init_pipe_state(compositor
))
407 if (!init_shaders(compositor
)) {
408 cleanup_pipe_state(compositor
);
411 if (!init_buffers(compositor
)) {
412 cleanup_shaders(compositor
);
413 cleanup_pipe_state(compositor
);
420 void vl_compositor_cleanup(struct vl_compositor
*compositor
)
424 cleanup_buffers(compositor
);
425 cleanup_shaders(compositor
);
426 cleanup_pipe_state(compositor
);
429 void vl_compositor_render(struct vl_compositor
*compositor
,
430 /*struct pipe_texture *backround,
431 struct pipe_video_rect *backround_area,*/
432 struct pipe_texture
*src_surface
,
433 enum pipe_mpeg12_picture_type picture_type
,
434 /*unsigned num_past_surfaces,
435 struct pipe_texture *past_surfaces,
436 unsigned num_future_surfaces,
437 struct pipe_texture *future_surfaces,*/
438 struct pipe_video_rect
*src_area
,
439 struct pipe_texture
*dst_surface
,
440 struct pipe_video_rect
*dst_area
,
441 /*unsigned num_layers,
442 struct pipe_texture *layers,
443 struct pipe_video_rect *layer_src_areas,
444 struct pipe_video_rect *layer_dst_areas*/
445 struct pipe_fence_handle
**fence
)
447 struct vertex_shader_consts
*vs_consts
;
454 assert(picture_type
== PIPE_MPEG12_PICTURE_TYPE_FRAME
);
456 compositor
->fb_state
.width
= dst_surface
->width0
;
457 compositor
->fb_state
.height
= dst_surface
->height0
;
458 compositor
->fb_state
.cbufs
[0] = compositor
->pipe
->screen
->get_tex_surface
460 compositor
->pipe
->screen
,
462 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ
| PIPE_BUFFER_USAGE_GPU_WRITE
465 compositor
->viewport
.scale
[0] = compositor
->fb_state
.width
;
466 compositor
->viewport
.scale
[1] = compositor
->fb_state
.height
;
467 compositor
->viewport
.scale
[2] = 1;
468 compositor
->viewport
.scale
[3] = 1;
469 compositor
->viewport
.translate
[0] = 0;
470 compositor
->viewport
.translate
[1] = 0;
471 compositor
->viewport
.translate
[2] = 0;
472 compositor
->viewport
.translate
[3] = 0;
474 compositor
->scissor
.maxx
= compositor
->fb_state
.width
;
475 compositor
->scissor
.maxy
= compositor
->fb_state
.height
;
477 compositor
->pipe
->set_framebuffer_state(compositor
->pipe
, &compositor
->fb_state
);
478 compositor
->pipe
->set_viewport_state(compositor
->pipe
, &compositor
->viewport
);
479 compositor
->pipe
->set_scissor_state(compositor
->pipe
, &compositor
->scissor
);
480 compositor
->pipe
->bind_fragment_sampler_states(compositor
->pipe
, 1, &compositor
->sampler
);
481 compositor
->pipe
->set_fragment_sampler_textures(compositor
->pipe
, 1, &src_surface
);
482 compositor
->pipe
->bind_vs_state(compositor
->pipe
, compositor
->vertex_shader
);
483 compositor
->pipe
->bind_fs_state(compositor
->pipe
, compositor
->fragment_shader
);
484 compositor
->pipe
->set_vertex_buffers(compositor
->pipe
, 2, compositor
->vertex_bufs
);
485 compositor
->pipe
->set_vertex_elements(compositor
->pipe
, 2, compositor
->vertex_elems
);
486 compositor
->pipe
->set_constant_buffer(compositor
->pipe
, PIPE_SHADER_VERTEX
, 0, compositor
->vs_const_buf
);
487 compositor
->pipe
->set_constant_buffer(compositor
->pipe
, PIPE_SHADER_FRAGMENT
, 0, compositor
->fs_const_buf
);
489 vs_consts
= pipe_buffer_map
491 compositor
->pipe
->screen
,
492 compositor
->vs_const_buf
,
493 PIPE_BUFFER_USAGE_CPU_WRITE
| PIPE_BUFFER_USAGE_DISCARD
496 vs_consts
->dst_scale
.x
= dst_area
->w
/ (float)compositor
->fb_state
.cbufs
[0]->width
;
497 vs_consts
->dst_scale
.y
= dst_area
->h
/ (float)compositor
->fb_state
.cbufs
[0]->height
;
498 vs_consts
->dst_scale
.z
= 1;
499 vs_consts
->dst_scale
.w
= 1;
500 vs_consts
->dst_trans
.x
= dst_area
->x
/ (float)compositor
->fb_state
.cbufs
[0]->width
;
501 vs_consts
->dst_trans
.y
= dst_area
->y
/ (float)compositor
->fb_state
.cbufs
[0]->height
;
502 vs_consts
->dst_trans
.z
= 0;
503 vs_consts
->dst_trans
.w
= 0;
505 vs_consts
->src_scale
.x
= src_area
->w
/ (float)src_surface
->width0
;
506 vs_consts
->src_scale
.y
= src_area
->h
/ (float)src_surface
->height0
;
507 vs_consts
->src_scale
.z
= 1;
508 vs_consts
->src_scale
.w
= 1;
509 vs_consts
->src_trans
.x
= src_area
->x
/ (float)src_surface
->width0
;
510 vs_consts
->src_trans
.y
= src_area
->y
/ (float)src_surface
->height0
;
511 vs_consts
->src_trans
.z
= 0;
512 vs_consts
->src_trans
.w
= 0;
514 pipe_buffer_unmap(compositor
->pipe
->screen
, compositor
->vs_const_buf
);
516 compositor
->pipe
->draw_arrays(compositor
->pipe
, PIPE_PRIM_TRIANGLE_STRIP
, 0, 4);
517 compositor
->pipe
->flush(compositor
->pipe
, PIPE_FLUSH_RENDER_CACHE
, fence
);
519 pipe_surface_reference(&compositor
->fb_state
.cbufs
[0], NULL
);
522 void vl_compositor_set_csc_matrix(struct vl_compositor
*compositor
, const float *mat
)
528 pipe_buffer_map(compositor
->pipe
->screen
, compositor
->fs_const_buf
, PIPE_BUFFER_USAGE_CPU_WRITE
),
530 sizeof(struct fragment_shader_consts
)
533 pipe_buffer_unmap(compositor
->pipe
->screen
, compositor
->fs_const_buf
);