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 <assert.h>
29
30 #include "pipe/p_compiler.h"
31 #include "pipe/p_context.h"
32
33 #include "util/u_memory.h"
34 #include "util/u_draw.h"
35 #include "util/u_surface.h"
36
37 #include "tgsi/tgsi_ureg.h"
38
39 #include "vl_csc.h"
40 #include "vl_types.h"
41 #include "vl_compositor.h"
42
43 #define MIN_DIRTY (0)
44 #define MAX_DIRTY (1 << 15)
45
46 enum VS_OUTPUT
47 {
48 VS_O_VPOS = 0,
49 VS_O_COLOR = 0,
50 VS_O_VTEX = 0,
51 VS_O_VTOP,
52 VS_O_VBOTTOM,
53 };
54
55 static void *
create_vert_shader(struct vl_compositor * c)56 create_vert_shader(struct vl_compositor *c)
57 {
58 struct ureg_program *shader;
59 struct ureg_src vpos, vtex, color;
60 struct ureg_dst tmp;
61 struct ureg_dst o_vpos, o_vtex, o_color;
62 struct ureg_dst o_vtop, o_vbottom;
63
64 shader = ureg_create(TGSI_PROCESSOR_VERTEX);
65 if (!shader)
66 return false;
67
68 vpos = ureg_DECL_vs_input(shader, 0);
69 vtex = ureg_DECL_vs_input(shader, 1);
70 color = ureg_DECL_vs_input(shader, 2);
71 tmp = ureg_DECL_temporary(shader);
72 o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);
73 o_color = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR);
74 o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX);
75 o_vtop = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP);
76 o_vbottom = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM);
77
78 /*
79 * o_vpos = vpos
80 * o_vtex = vtex
81 * o_color = color
82 */
83 ureg_MOV(shader, o_vpos, vpos);
84 ureg_MOV(shader, o_vtex, vtex);
85 ureg_MOV(shader, o_color, color);
86
87 /*
88 * tmp.x = vtex.w / 2
89 * tmp.y = vtex.w / 4
90 *
91 * o_vtop.x = vtex.x
92 * o_vtop.y = vtex.y * tmp.x + 0.25f
93 * o_vtop.z = vtex.y * tmp.y + 0.25f
94 * o_vtop.w = 1 / tmp.x
95 *
96 * o_vbottom.x = vtex.x
97 * o_vbottom.y = vtex.y * tmp.x - 0.25f
98 * o_vbottom.z = vtex.y * tmp.y - 0.25f
99 * o_vbottom.w = 1 / tmp.y
100 */
101 ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X),
102 ureg_scalar(vtex, TGSI_SWIZZLE_W), ureg_imm1f(shader, 0.5f));
103 ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y),
104 ureg_scalar(vtex, TGSI_SWIZZLE_W), ureg_imm1f(shader, 0.25f));
105
106 ureg_MOV(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_X), vtex);
107 ureg_MAD(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_Y), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
108 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), ureg_imm1f(shader, 0.25f));
109 ureg_MAD(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_Z), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
110 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y), ureg_imm1f(shader, 0.25f));
111 ureg_RCP(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_W),
112 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X));
113
114 ureg_MOV(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_X), vtex);
115 ureg_MAD(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_Y), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
116 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), ureg_imm1f(shader, -0.25f));
117 ureg_MAD(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_Z), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
118 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y), ureg_imm1f(shader, -0.25f));
119 ureg_RCP(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_W),
120 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y));
121
122 ureg_END(shader);
123
124 return ureg_create_shader_and_destroy(shader, c->pipe);
125 }
126
127 static void *
create_frag_shader_video_buffer(struct vl_compositor * c)128 create_frag_shader_video_buffer(struct vl_compositor *c)
129 {
130 struct ureg_program *shader;
131 struct ureg_src tc;
132 struct ureg_src csc[3];
133 struct ureg_src sampler[3];
134 struct ureg_dst texel;
135 struct ureg_dst fragment;
136 unsigned i;
137
138 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
139 if (!shader)
140 return false;
141
142 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
143 for (i = 0; i < 3; ++i) {
144 csc[i] = ureg_DECL_constant(shader, i);
145 sampler[i] = ureg_DECL_sampler(shader, i);
146 }
147 texel = ureg_DECL_temporary(shader);
148 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
149
150 /*
151 * texel.xyz = tex(tc, sampler[i])
152 * fragment = csc * texel
153 */
154 for (i = 0; i < 3; ++i)
155 ureg_TEX(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), TGSI_TEXTURE_3D, tc, sampler[i]);
156
157 ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));
158
159 for (i = 0; i < 3; ++i)
160 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));
161
162 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));
163
164 ureg_release_temporary(shader, texel);
165 ureg_END(shader);
166
167 return ureg_create_shader_and_destroy(shader, c->pipe);
168 }
169
170 static void *
create_frag_shader_weave(struct vl_compositor * c)171 create_frag_shader_weave(struct vl_compositor *c)
172 {
173 struct ureg_program *shader;
174 struct ureg_src i_tc[2];
175 struct ureg_src csc[3];
176 struct ureg_src sampler[3];
177 struct ureg_dst t_tc[2];
178 struct ureg_dst t_texel[2];
179 struct ureg_dst o_fragment;
180 unsigned i, j;
181
182 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
183 if (!shader)
184 return false;
185
186 i_tc[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP, TGSI_INTERPOLATE_LINEAR);
187 i_tc[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM, TGSI_INTERPOLATE_LINEAR);
188
189 for (i = 0; i < 3; ++i) {
190 csc[i] = ureg_DECL_constant(shader, i);
191 sampler[i] = ureg_DECL_sampler(shader, i);
192 }
193
194 for (i = 0; i < 2; ++i) {
195 t_tc[i] = ureg_DECL_temporary(shader);
196 t_texel[i] = ureg_DECL_temporary(shader);
197 }
198 o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
199
200 /* calculate the texture offsets
201 * t_tc.x = i_tc.x
202 * t_tc.y = (round(i_tc.y) + 0.5) / height * 2
203 */
204 for (i = 0; i < 2; ++i) {
205 ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_X), i_tc[i]);
206 ureg_ROUND(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ), i_tc[i]);
207 ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_W),
208 ureg_imm1f(shader, i ? 0.75f : 0.25f));
209 ureg_ADD(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ),
210 ureg_src(t_tc[i]), ureg_imm1f(shader, 0.5f));
211 ureg_MUL(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_Y),
212 ureg_src(t_tc[i]), ureg_scalar(i_tc[0], TGSI_SWIZZLE_W));
213 ureg_MUL(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_Z),
214 ureg_src(t_tc[i]), ureg_scalar(i_tc[1], TGSI_SWIZZLE_W));
215 }
216
217 /* fetch the texels
218 * texel[0..1].x = tex(t_tc[0..1][0])
219 * texel[0..1].y = tex(t_tc[0..1][1])
220 * texel[0..1].z = tex(t_tc[0..1][2])
221 */
222 for (i = 0; i < 2; ++i)
223 for (j = 0; j < 3; ++j) {
224 struct ureg_src src = ureg_swizzle(ureg_src(t_tc[i]),
225 TGSI_SWIZZLE_X, j ? TGSI_SWIZZLE_Z : TGSI_SWIZZLE_Y, TGSI_SWIZZLE_W, TGSI_SWIZZLE_W);
226
227 ureg_TEX(shader, ureg_writemask(t_texel[i], TGSI_WRITEMASK_X << j),
228 TGSI_TEXTURE_3D, src, sampler[j]);
229 }
230
231 /* calculate linear interpolation factor
232 * factor = |round(i_tc.y) - i_tc.y| * 2
233 */
234 ureg_ROUND(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ), i_tc[0]);
235 ureg_ADD(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ),
236 ureg_src(t_tc[0]), ureg_negate(i_tc[0]));
237 ureg_MUL(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_XY),
238 ureg_abs(ureg_src(t_tc[0])), ureg_imm1f(shader, 2.0f));
239 ureg_LRP(shader, t_texel[0], ureg_swizzle(ureg_src(t_tc[0]),
240 TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_Z),
241 ureg_src(t_texel[1]), ureg_src(t_texel[0]));
242
243 /* and finally do colour space transformation
244 * fragment = csc * texel
245 */
246 ureg_MOV(shader, ureg_writemask(t_texel[0], TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));
247 for (i = 0; i < 3; ++i)
248 ureg_DP4(shader, ureg_writemask(o_fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(t_texel[0]));
249
250 ureg_MOV(shader, ureg_writemask(o_fragment, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));
251
252 for (i = 0; i < 2; ++i) {
253 ureg_release_temporary(shader, t_texel[i]);
254 ureg_release_temporary(shader, t_tc[i]);
255 }
256
257 ureg_END(shader);
258
259 return ureg_create_shader_and_destroy(shader, c->pipe);
260 }
261
262 static void *
create_frag_shader_palette(struct vl_compositor * c,bool include_cc)263 create_frag_shader_palette(struct vl_compositor *c, bool include_cc)
264 {
265 struct ureg_program *shader;
266 struct ureg_src csc[3];
267 struct ureg_src tc;
268 struct ureg_src sampler;
269 struct ureg_src palette;
270 struct ureg_dst texel;
271 struct ureg_dst fragment;
272 unsigned i;
273
274 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
275 if (!shader)
276 return false;
277
278 for (i = 0; include_cc && i < 3; ++i)
279 csc[i] = ureg_DECL_constant(shader, i);
280
281 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
282 sampler = ureg_DECL_sampler(shader, 0);
283 palette = ureg_DECL_sampler(shader, 1);
284
285 texel = ureg_DECL_temporary(shader);
286 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
287
288 /*
289 * texel = tex(tc, sampler)
290 * fragment.xyz = tex(texel, palette) * csc
291 * fragment.a = texel.a
292 */
293 ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
294 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_src(texel));
295
296 if (include_cc) {
297 ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette);
298 for (i = 0; i < 3; ++i)
299 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));
300 } else {
301 ureg_TEX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XYZ),
302 TGSI_TEXTURE_1D, ureg_src(texel), palette);
303 }
304
305 ureg_release_temporary(shader, texel);
306 ureg_END(shader);
307
308 return ureg_create_shader_and_destroy(shader, c->pipe);
309 }
310
311 static void *
create_frag_shader_rgba(struct vl_compositor * c)312 create_frag_shader_rgba(struct vl_compositor *c)
313 {
314 struct ureg_program *shader;
315 struct ureg_src tc, color, sampler;
316 struct ureg_dst texel, fragment;
317
318 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
319 if (!shader)
320 return false;
321
322 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
323 color = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR, TGSI_INTERPOLATE_LINEAR);
324 sampler = ureg_DECL_sampler(shader, 0);
325 texel = ureg_DECL_temporary(shader);
326 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
327
328 /*
329 * fragment = tex(tc, sampler)
330 */
331 ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
332 ureg_MUL(shader, fragment, ureg_src(texel), color);
333 ureg_END(shader);
334
335 return ureg_create_shader_and_destroy(shader, c->pipe);
336 }
337
338 static bool
init_shaders(struct vl_compositor * c)339 init_shaders(struct vl_compositor *c)
340 {
341 assert(c);
342
343 c->vs = create_vert_shader(c);
344 if (!c->vs) {
345 debug_printf("Unable to create vertex shader.\n");
346 return false;
347 }
348
349 c->fs_video_buffer = create_frag_shader_video_buffer(c);
350 if (!c->fs_video_buffer) {
351 debug_printf("Unable to create YCbCr-to-RGB fragment shader.\n");
352 return false;
353 }
354
355 c->fs_weave = create_frag_shader_weave(c);
356 if (!c->fs_weave) {
357 debug_printf("Unable to create YCbCr-to-RGB weave fragment shader.\n");
358 return false;
359 }
360
361 c->fs_palette.yuv = create_frag_shader_palette(c, true);
362 if (!c->fs_palette.yuv) {
363 debug_printf("Unable to create YUV-Palette-to-RGB fragment shader.\n");
364 return false;
365 }
366
367 c->fs_palette.rgb = create_frag_shader_palette(c, false);
368 if (!c->fs_palette.rgb) {
369 debug_printf("Unable to create RGB-Palette-to-RGB fragment shader.\n");
370 return false;
371 }
372
373 c->fs_rgba = create_frag_shader_rgba(c);
374 if (!c->fs_rgba) {
375 debug_printf("Unable to create RGB-to-RGB fragment shader.\n");
376 return false;
377 }
378
379 return true;
380 }
381
cleanup_shaders(struct vl_compositor * c)382 static void cleanup_shaders(struct vl_compositor *c)
383 {
384 assert(c);
385
386 c->pipe->delete_vs_state(c->pipe, c->vs);
387 c->pipe->delete_fs_state(c->pipe, c->fs_video_buffer);
388 c->pipe->delete_fs_state(c->pipe, c->fs_weave);
389 c->pipe->delete_fs_state(c->pipe, c->fs_palette.yuv);
390 c->pipe->delete_fs_state(c->pipe, c->fs_palette.rgb);
391 c->pipe->delete_fs_state(c->pipe, c->fs_rgba);
392 }
393
394 static bool
init_pipe_state(struct vl_compositor * c)395 init_pipe_state(struct vl_compositor *c)
396 {
397 struct pipe_rasterizer_state rast;
398 struct pipe_sampler_state sampler;
399 struct pipe_blend_state blend;
400 struct pipe_depth_stencil_alpha_state dsa;
401 unsigned i;
402
403 assert(c);
404
405 c->fb_state.nr_cbufs = 1;
406 c->fb_state.zsbuf = NULL;
407
408 memset(&sampler, 0, sizeof(sampler));
409 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
410 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
411 sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
412 sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
413 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
414 sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
415 sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
416 sampler.compare_func = PIPE_FUNC_ALWAYS;
417 sampler.normalized_coords = 1;
418
419 c->sampler_linear = c->pipe->create_sampler_state(c->pipe, &sampler);
420
421 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
422 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
423 c->sampler_nearest = c->pipe->create_sampler_state(c->pipe, &sampler);
424
425 memset(&blend, 0, sizeof blend);
426 blend.independent_blend_enable = 0;
427 blend.rt[0].blend_enable = 0;
428 blend.logicop_enable = 0;
429 blend.logicop_func = PIPE_LOGICOP_CLEAR;
430 blend.rt[0].colormask = PIPE_MASK_RGBA;
431 blend.dither = 0;
432 c->blend_clear = c->pipe->create_blend_state(c->pipe, &blend);
433
434 blend.rt[0].blend_enable = 1;
435 blend.rt[0].rgb_func = PIPE_BLEND_ADD;
436 blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
437 blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
438 blend.rt[0].alpha_func = PIPE_BLEND_ADD;
439 blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
440 blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
441 c->blend_add = c->pipe->create_blend_state(c->pipe, &blend);
442
443 memset(&rast, 0, sizeof rast);
444 rast.flatshade = 0;
445 rast.front_ccw = 1;
446 rast.cull_face = PIPE_FACE_NONE;
447 rast.fill_back = PIPE_POLYGON_MODE_FILL;
448 rast.fill_front = PIPE_POLYGON_MODE_FILL;
449 rast.scissor = 1;
450 rast.line_width = 1;
451 rast.point_size_per_vertex = 1;
452 rast.offset_units = 1;
453 rast.offset_scale = 1;
454 rast.gl_rasterization_rules = 1;
455 rast.depth_clip = 1;
456
457 c->rast = c->pipe->create_rasterizer_state(c->pipe, &rast);
458
459 memset(&dsa, 0, sizeof dsa);
460 dsa.depth.enabled = 0;
461 dsa.depth.writemask = 0;
462 dsa.depth.func = PIPE_FUNC_ALWAYS;
463 for (i = 0; i < 2; ++i) {
464 dsa.stencil[i].enabled = 0;
465 dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
466 dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
467 dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
468 dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
469 dsa.stencil[i].valuemask = 0;
470 dsa.stencil[i].writemask = 0;
471 }
472 dsa.alpha.enabled = 0;
473 dsa.alpha.func = PIPE_FUNC_ALWAYS;
474 dsa.alpha.ref_value = 0;
475 c->dsa = c->pipe->create_depth_stencil_alpha_state(c->pipe, &dsa);
476 c->pipe->bind_depth_stencil_alpha_state(c->pipe, c->dsa);
477
478 return true;
479 }
480
cleanup_pipe_state(struct vl_compositor * c)481 static void cleanup_pipe_state(struct vl_compositor *c)
482 {
483 assert(c);
484
485 /* Asserted in softpipe_delete_fs_state() for some reason */
486 c->pipe->bind_vs_state(c->pipe, NULL);
487 c->pipe->bind_fs_state(c->pipe, NULL);
488
489 c->pipe->delete_depth_stencil_alpha_state(c->pipe, c->dsa);
490 c->pipe->delete_sampler_state(c->pipe, c->sampler_linear);
491 c->pipe->delete_sampler_state(c->pipe, c->sampler_nearest);
492 c->pipe->delete_blend_state(c->pipe, c->blend_clear);
493 c->pipe->delete_blend_state(c->pipe, c->blend_add);
494 c->pipe->delete_rasterizer_state(c->pipe, c->rast);
495 }
496
497 static bool
create_vertex_buffer(struct vl_compositor * c)498 create_vertex_buffer(struct vl_compositor *c)
499 {
500 assert(c);
501
502 pipe_resource_reference(&c->vertex_buf.buffer, NULL);
503 c->vertex_buf.buffer = pipe_buffer_create
504 (
505 c->pipe->screen,
506 PIPE_BIND_VERTEX_BUFFER,
507 PIPE_USAGE_STREAM,
508 c->vertex_buf.stride * VL_COMPOSITOR_MAX_LAYERS * 4
509 );
510
511 return c->vertex_buf.buffer != NULL;
512 }
513
514 static bool
init_buffers(struct vl_compositor * c)515 init_buffers(struct vl_compositor *c)
516 {
517 struct pipe_vertex_element vertex_elems[3];
518
519 assert(c);
520
521 /*
522 * Create our vertex buffer and vertex buffer elements
523 */
524 c->vertex_buf.stride = sizeof(struct vertex2f) + sizeof(struct vertex4f) * 2;
525 c->vertex_buf.buffer_offset = 0;
526 create_vertex_buffer(c);
527
528 vertex_elems[0].src_offset = 0;
529 vertex_elems[0].instance_divisor = 0;
530 vertex_elems[0].vertex_buffer_index = 0;
531 vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
532 vertex_elems[1].src_offset = sizeof(struct vertex2f);
533 vertex_elems[1].instance_divisor = 0;
534 vertex_elems[1].vertex_buffer_index = 0;
535 vertex_elems[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
536 vertex_elems[2].src_offset = sizeof(struct vertex2f) + sizeof(struct vertex4f);
537 vertex_elems[2].instance_divisor = 0;
538 vertex_elems[2].vertex_buffer_index = 0;
539 vertex_elems[2].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
540 c->vertex_elems_state = c->pipe->create_vertex_elements_state(c->pipe, 3, vertex_elems);
541
542 return true;
543 }
544
545 static void
cleanup_buffers(struct vl_compositor * c)546 cleanup_buffers(struct vl_compositor *c)
547 {
548 assert(c);
549
550 c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems_state);
551 pipe_resource_reference(&c->vertex_buf.buffer, NULL);
552 }
553
554 static INLINE struct u_rect
default_rect(struct vl_compositor_layer * layer)555 default_rect(struct vl_compositor_layer *layer)
556 {
557 struct pipe_resource *res = layer->sampler_views[0]->texture;
558 struct u_rect rect = { 0, res->width0, 0, res->height0 * res->depth0 };
559 return rect;
560 }
561
562 static INLINE struct vertex2f
calc_topleft(struct vertex2f size,struct u_rect rect)563 calc_topleft(struct vertex2f size, struct u_rect rect)
564 {
565 struct vertex2f res = { rect.x0 / size.x, rect.y0 / size.y };
566 return res;
567 }
568
569 static INLINE struct vertex2f
calc_bottomright(struct vertex2f size,struct u_rect rect)570 calc_bottomright(struct vertex2f size, struct u_rect rect)
571 {
572 struct vertex2f res = { rect.x1 / size.x, rect.y1 / size.y };
573 return res;
574 }
575
576 static INLINE void
calc_src_and_dst(struct vl_compositor_layer * layer,unsigned width,unsigned height,struct u_rect src,struct u_rect dst)577 calc_src_and_dst(struct vl_compositor_layer *layer, unsigned width, unsigned height,
578 struct u_rect src, struct u_rect dst)
579 {
580 struct vertex2f size = { width, height };
581
582 layer->src.tl = calc_topleft(size, src);
583 layer->src.br = calc_bottomright(size, src);
584 layer->dst.tl = calc_topleft(size, dst);
585 layer->dst.br = calc_bottomright(size, dst);
586 layer->zw.x = 0.0f;
587 layer->zw.y = size.y;
588 }
589
590 static void
gen_rect_verts(struct vertex2f * vb,struct vl_compositor_layer * layer)591 gen_rect_verts(struct vertex2f *vb, struct vl_compositor_layer *layer)
592 {
593 assert(vb && layer);
594
595 vb[ 0].x = layer->dst.tl.x;
596 vb[ 0].y = layer->dst.tl.y;
597 vb[ 1].x = layer->src.tl.x;
598 vb[ 1].y = layer->src.tl.y;
599 vb[ 2] = layer->zw;
600 vb[ 3].x = layer->colors[0].x;
601 vb[ 3].y = layer->colors[0].y;
602 vb[ 4].x = layer->colors[0].z;
603 vb[ 4].y = layer->colors[0].w;
604
605 vb[ 5].x = layer->dst.br.x;
606 vb[ 5].y = layer->dst.tl.y;
607 vb[ 6].x = layer->src.br.x;
608 vb[ 6].y = layer->src.tl.y;
609 vb[ 7] = layer->zw;
610 vb[ 8].x = layer->colors[1].x;
611 vb[ 8].y = layer->colors[1].y;
612 vb[ 9].x = layer->colors[1].z;
613 vb[ 9].y = layer->colors[1].w;
614
615 vb[10].x = layer->dst.br.x;
616 vb[10].y = layer->dst.br.y;
617 vb[11].x = layer->src.br.x;
618 vb[11].y = layer->src.br.y;
619 vb[12] = layer->zw;
620 vb[13].x = layer->colors[2].x;
621 vb[13].y = layer->colors[2].y;
622 vb[14].x = layer->colors[2].z;
623 vb[14].y = layer->colors[2].w;
624
625 vb[15].x = layer->dst.tl.x;
626 vb[15].y = layer->dst.br.y;
627 vb[16].x = layer->src.tl.x;
628 vb[16].y = layer->src.br.y;
629 vb[17] = layer->zw;
630 vb[18].x = layer->colors[3].x;
631 vb[18].y = layer->colors[3].y;
632 vb[19].x = layer->colors[3].z;
633 vb[19].y = layer->colors[3].w;
634 }
635
636 static INLINE struct u_rect
calc_drawn_area(struct vl_compositor_state * s,struct vl_compositor_layer * layer)637 calc_drawn_area(struct vl_compositor_state *s, struct vl_compositor_layer *layer)
638 {
639 struct u_rect result;
640
641 // scale
642 result.x0 = layer->dst.tl.x * layer->viewport.scale[0] + layer->viewport.translate[0];
643 result.y0 = layer->dst.tl.y * layer->viewport.scale[1] + layer->viewport.translate[1];
644 result.x1 = layer->dst.br.x * layer->viewport.scale[0] + layer->viewport.translate[0];
645 result.y1 = layer->dst.br.y * layer->viewport.scale[1] + layer->viewport.translate[1];
646
647 // and clip
648 result.x0 = MAX2(result.x0, s->scissor.minx);
649 result.y0 = MAX2(result.y0, s->scissor.miny);
650 result.x1 = MIN2(result.x1, s->scissor.maxx);
651 result.y1 = MIN2(result.y1, s->scissor.maxy);
652 return result;
653 }
654
655 static void
gen_vertex_data(struct vl_compositor * c,struct vl_compositor_state * s,struct u_rect * dirty)656 gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty)
657 {
658 struct vertex2f *vb;
659 struct pipe_transfer *buf_transfer;
660 unsigned i;
661
662 assert(c);
663
664 vb = pipe_buffer_map(c->pipe, c->vertex_buf.buffer,
665 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE | PIPE_TRANSFER_DONTBLOCK,
666 &buf_transfer);
667
668 if (!vb) {
669 // If buffer is still locked from last draw create a new one
670 create_vertex_buffer(c);
671 vb = pipe_buffer_map(c->pipe, c->vertex_buf.buffer,
672 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
673 &buf_transfer);
674 }
675
676 for (i = 0; i < VL_COMPOSITOR_MAX_LAYERS; i++) {
677 if (s->used_layers & (1 << i)) {
678 struct vl_compositor_layer *layer = &s->layers[i];
679 gen_rect_verts(vb, layer);
680 vb += 20;
681
682 if (!layer->viewport_valid) {
683 layer->viewport.scale[0] = c->fb_state.width;
684 layer->viewport.scale[1] = c->fb_state.height;
685 layer->viewport.translate[0] = 0;
686 layer->viewport.translate[1] = 0;
687 }
688
689 if (dirty && layer->clearing) {
690 struct u_rect drawn = calc_drawn_area(s, layer);
691 if (
692 dirty->x0 >= drawn.x0 &&
693 dirty->y0 >= drawn.y0 &&
694 dirty->x1 <= drawn.x1 &&
695 dirty->y1 <= drawn.y1) {
696
697 // We clear the dirty area anyway, no need for clear_render_target
698 dirty->x0 = dirty->y0 = MAX_DIRTY;
699 dirty->x1 = dirty->y1 = MIN_DIRTY;
700 }
701 }
702 }
703 }
704
705 pipe_buffer_unmap(c->pipe, buf_transfer);
706 }
707
708 static void
draw_layers(struct vl_compositor * c,struct vl_compositor_state * s,struct u_rect * dirty)709 draw_layers(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty)
710 {
711 unsigned vb_index, i;
712
713 assert(c);
714
715 for (i = 0, vb_index = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
716 if (s->used_layers & (1 << i)) {
717 struct vl_compositor_layer *layer = &s->layers[i];
718 struct pipe_sampler_view **samplers = &layer->sampler_views[0];
719 unsigned num_sampler_views = !samplers[1] ? 1 : !samplers[2] ? 2 : 3;
720 void *blend = layer->blend ? layer->blend : i ? c->blend_add : c->blend_clear;
721
722 c->pipe->bind_blend_state(c->pipe, blend);
723 c->pipe->set_viewport_state(c->pipe, &layer->viewport);
724 c->pipe->bind_fs_state(c->pipe, layer->fs);
725 c->pipe->bind_fragment_sampler_states(c->pipe, num_sampler_views, layer->samplers);
726 c->pipe->set_fragment_sampler_views(c->pipe, num_sampler_views, samplers);
727 util_draw_arrays(c->pipe, PIPE_PRIM_QUADS, vb_index * 4, 4);
728 vb_index++;
729
730 if (dirty) {
731 // Remember the currently drawn area as dirty for the next draw command
732 struct u_rect drawn = calc_drawn_area(s, layer);
733 dirty->x0 = MIN2(drawn.x0, dirty->x0);
734 dirty->y0 = MIN2(drawn.y0, dirty->y0);
735 dirty->x1 = MAX2(drawn.x1, dirty->x1);
736 dirty->y1 = MAX2(drawn.y1, dirty->y1);
737 }
738 }
739 }
740 }
741
742 void
vl_compositor_reset_dirty_area(struct u_rect * dirty)743 vl_compositor_reset_dirty_area(struct u_rect *dirty)
744 {
745 assert(dirty);
746
747 dirty->x0 = dirty->y0 = MIN_DIRTY;
748 dirty->x1 = dirty->y1 = MAX_DIRTY;
749 }
750
751 void
vl_compositor_set_clear_color(struct vl_compositor_state * s,union pipe_color_union * color)752 vl_compositor_set_clear_color(struct vl_compositor_state *s, union pipe_color_union *color)
753 {
754 assert(s);
755 assert(color);
756
757 s->clear_color = *color;
758 }
759
760 void
vl_compositor_get_clear_color(struct vl_compositor_state * s,union pipe_color_union * color)761 vl_compositor_get_clear_color(struct vl_compositor_state *s, union pipe_color_union *color)
762 {
763 assert(s);
764 assert(color);
765
766 *color = s->clear_color;
767 }
768
769 void
vl_compositor_clear_layers(struct vl_compositor_state * s)770 vl_compositor_clear_layers(struct vl_compositor_state *s)
771 {
772 unsigned i, j;
773
774 assert(s);
775
776 s->used_layers = 0;
777 for ( i = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
778 struct vertex4f v_one = { 1.0f, 1.0f, 1.0f, 1.0f };
779 s->layers[i].clearing = i ? false : true;
780 s->layers[i].blend = NULL;
781 s->layers[i].fs = NULL;
782 s->layers[i].viewport.scale[2] = 1;
783 s->layers[i].viewport.scale[3] = 1;
784 s->layers[i].viewport.translate[2] = 0;
785 s->layers[i].viewport.translate[3] = 0;
786
787 for ( j = 0; j < 3; j++)
788 pipe_sampler_view_reference(&s->layers[i].sampler_views[j], NULL);
789 for ( j = 0; j < 4; ++j)
790 s->layers[i].colors[j] = v_one;
791 }
792 }
793
794 void
vl_compositor_cleanup(struct vl_compositor * c)795 vl_compositor_cleanup(struct vl_compositor *c)
796 {
797 assert(c);
798
799 cleanup_buffers(c);
800 cleanup_shaders(c);
801 cleanup_pipe_state(c);
802 }
803
804 void
vl_compositor_set_csc_matrix(struct vl_compositor_state * s,vl_csc_matrix const * matrix)805 vl_compositor_set_csc_matrix(struct vl_compositor_state *s, vl_csc_matrix const *matrix)
806 {
807 struct pipe_transfer *buf_transfer;
808
809 assert(s);
810
811 memcpy
812 (
813 pipe_buffer_map(s->pipe, s->csc_matrix,
814 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
815 &buf_transfer),
816 matrix,
817 sizeof(vl_csc_matrix)
818 );
819
820 pipe_buffer_unmap(s->pipe, buf_transfer);
821 }
822
823 void
vl_compositor_set_dst_clip(struct vl_compositor_state * s,struct u_rect * dst_clip)824 vl_compositor_set_dst_clip(struct vl_compositor_state *s, struct u_rect *dst_clip)
825 {
826 assert(s);
827
828 s->scissor_valid = dst_clip != NULL;
829 if (dst_clip) {
830 s->scissor.minx = dst_clip->x0;
831 s->scissor.miny = dst_clip->y0;
832 s->scissor.maxx = dst_clip->x1;
833 s->scissor.maxy = dst_clip->y1;
834 }
835 }
836
837 void
vl_compositor_set_layer_blend(struct vl_compositor_state * s,unsigned layer,void * blend,bool is_clearing)838 vl_compositor_set_layer_blend(struct vl_compositor_state *s,
839 unsigned layer, void *blend,
840 bool is_clearing)
841 {
842 assert(s && blend);
843
844 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
845
846 s->layers[layer].clearing = is_clearing;
847 s->layers[layer].blend = blend;
848 }
849
850 void
vl_compositor_set_layer_dst_area(struct vl_compositor_state * s,unsigned layer,struct u_rect * dst_area)851 vl_compositor_set_layer_dst_area(struct vl_compositor_state *s,
852 unsigned layer, struct u_rect *dst_area)
853 {
854 assert(s);
855
856 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
857
858 s->layers[layer].viewport_valid = dst_area != NULL;
859 if (dst_area) {
860 s->layers[layer].viewport.scale[0] = dst_area->x1 - dst_area->x0;
861 s->layers[layer].viewport.scale[1] = dst_area->y1 - dst_area->y0;
862 s->layers[layer].viewport.translate[0] = dst_area->x0;
863 s->layers[layer].viewport.translate[1] = dst_area->y0;
864 }
865 }
866
867 void
vl_compositor_set_buffer_layer(struct vl_compositor_state * s,struct vl_compositor * c,unsigned layer,struct pipe_video_buffer * buffer,struct u_rect * src_rect,struct u_rect * dst_rect,enum vl_compositor_deinterlace deinterlace)868 vl_compositor_set_buffer_layer(struct vl_compositor_state *s,
869 struct vl_compositor *c,
870 unsigned layer,
871 struct pipe_video_buffer *buffer,
872 struct u_rect *src_rect,
873 struct u_rect *dst_rect,
874 enum vl_compositor_deinterlace deinterlace)
875 {
876 struct pipe_sampler_view **sampler_views;
877 unsigned i;
878
879 assert(s && c && buffer);
880
881 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
882
883 s->used_layers |= 1 << layer;
884 sampler_views = buffer->get_sampler_view_components(buffer);
885 for (i = 0; i < 3; ++i) {
886 s->layers[layer].samplers[i] = c->sampler_linear;
887 pipe_sampler_view_reference(&s->layers[layer].sampler_views[i], sampler_views[i]);
888 }
889
890 calc_src_and_dst(&s->layers[layer], buffer->width, buffer->height,
891 src_rect ? *src_rect : default_rect(&s->layers[layer]),
892 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
893
894 if (buffer->interlaced) {
895 float half_a_line = 0.5f / s->layers[layer].zw.y;
896 switch(deinterlace) {
897 case VL_COMPOSITOR_WEAVE:
898 s->layers[layer].fs = c->fs_weave;
899 break;
900
901 case VL_COMPOSITOR_BOB_TOP:
902 s->layers[layer].zw.x = 0.25f;
903 s->layers[layer].src.tl.y += half_a_line;
904 s->layers[layer].src.br.y += half_a_line;
905 s->layers[layer].fs = c->fs_video_buffer;
906 break;
907
908 case VL_COMPOSITOR_BOB_BOTTOM:
909 s->layers[layer].zw.x = 0.75f;
910 s->layers[layer].src.tl.y -= half_a_line;
911 s->layers[layer].src.br.y -= half_a_line;
912 s->layers[layer].fs = c->fs_video_buffer;
913 break;
914 }
915
916 } else
917 s->layers[layer].fs = c->fs_video_buffer;
918 }
919
920 void
vl_compositor_set_palette_layer(struct vl_compositor_state * s,struct vl_compositor * c,unsigned layer,struct pipe_sampler_view * indexes,struct pipe_sampler_view * palette,struct u_rect * src_rect,struct u_rect * dst_rect,bool include_color_conversion)921 vl_compositor_set_palette_layer(struct vl_compositor_state *s,
922 struct vl_compositor *c,
923 unsigned layer,
924 struct pipe_sampler_view *indexes,
925 struct pipe_sampler_view *palette,
926 struct u_rect *src_rect,
927 struct u_rect *dst_rect,
928 bool include_color_conversion)
929 {
930 assert(s && c && indexes && palette);
931
932 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
933
934 s->used_layers |= 1 << layer;
935
936 s->layers[layer].fs = include_color_conversion ?
937 c->fs_palette.yuv : c->fs_palette.rgb;
938
939 s->layers[layer].samplers[0] = c->sampler_linear;
940 s->layers[layer].samplers[1] = c->sampler_nearest;
941 s->layers[layer].samplers[2] = NULL;
942 pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], indexes);
943 pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], palette);
944 pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
945 calc_src_and_dst(&s->layers[layer], indexes->texture->width0, indexes->texture->height0,
946 src_rect ? *src_rect : default_rect(&s->layers[layer]),
947 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
948 }
949
950 void
vl_compositor_set_rgba_layer(struct vl_compositor_state * s,struct vl_compositor * c,unsigned layer,struct pipe_sampler_view * rgba,struct u_rect * src_rect,struct u_rect * dst_rect,struct vertex4f * colors)951 vl_compositor_set_rgba_layer(struct vl_compositor_state *s,
952 struct vl_compositor *c,
953 unsigned layer,
954 struct pipe_sampler_view *rgba,
955 struct u_rect *src_rect,
956 struct u_rect *dst_rect,
957 struct vertex4f *colors)
958 {
959 unsigned i;
960
961 assert(s && c && rgba);
962
963 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
964
965 s->used_layers |= 1 << layer;
966 s->layers[layer].fs = c->fs_rgba;
967 s->layers[layer].samplers[0] = c->sampler_linear;
968 s->layers[layer].samplers[1] = NULL;
969 s->layers[layer].samplers[2] = NULL;
970 pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], rgba);
971 pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], NULL);
972 pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
973 calc_src_and_dst(&s->layers[layer], rgba->texture->width0, rgba->texture->height0,
974 src_rect ? *src_rect : default_rect(&s->layers[layer]),
975 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
976
977 if (colors)
978 for (i = 0; i < 4; ++i)
979 s->layers[layer].colors[i] = colors[i];
980 }
981
982 void
vl_compositor_render(struct vl_compositor_state * s,struct vl_compositor * c,struct pipe_surface * dst_surface,struct u_rect * dirty_area)983 vl_compositor_render(struct vl_compositor_state *s,
984 struct vl_compositor *c,
985 struct pipe_surface *dst_surface,
986 struct u_rect *dirty_area)
987 {
988 assert(c);
989 assert(dst_surface);
990
991 c->fb_state.width = dst_surface->width;
992 c->fb_state.height = dst_surface->height;
993 c->fb_state.cbufs[0] = dst_surface;
994
995 if (!s->scissor_valid) {
996 s->scissor.minx = 0;
997 s->scissor.miny = 0;
998 s->scissor.maxx = dst_surface->width;
999 s->scissor.maxy = dst_surface->height;
1000 }
1001
1002 gen_vertex_data(c, s, dirty_area);
1003
1004 if (dirty_area && (dirty_area->x0 < dirty_area->x1 ||
1005 dirty_area->y0 < dirty_area->y1)) {
1006
1007 c->pipe->clear_render_target(c->pipe, dst_surface, &s->clear_color,
1008 0, 0, dst_surface->width, dst_surface->height);
1009 dirty_area->x0 = dirty_area->y0 = MAX_DIRTY;
1010 dirty_area->x1 = dirty_area->y1 = MIN_DIRTY;
1011 }
1012
1013 c->pipe->set_scissor_state(c->pipe, &s->scissor);
1014 c->pipe->set_framebuffer_state(c->pipe, &c->fb_state);
1015 c->pipe->bind_vs_state(c->pipe, c->vs);
1016 c->pipe->set_vertex_buffers(c->pipe, 1, &c->vertex_buf);
1017 c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state);
1018 pipe_set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, s->csc_matrix);
1019 c->pipe->bind_rasterizer_state(c->pipe, c->rast);
1020
1021 draw_layers(c, s, dirty_area);
1022 }
1023
1024 bool
vl_compositor_init(struct vl_compositor * c,struct pipe_context * pipe)1025 vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe)
1026 {
1027 assert(c);
1028
1029 memset(c, 0, sizeof(*c));
1030
1031 c->pipe = pipe;
1032
1033 if (!init_pipe_state(c))
1034 return false;
1035
1036 if (!init_shaders(c)) {
1037 cleanup_pipe_state(c);
1038 return false;
1039 }
1040
1041 if (!init_buffers(c)) {
1042 cleanup_shaders(c);
1043 cleanup_pipe_state(c);
1044 return false;
1045 }
1046
1047 return true;
1048 }
1049
1050 bool
vl_compositor_init_state(struct vl_compositor_state * s,struct pipe_context * pipe)1051 vl_compositor_init_state(struct vl_compositor_state *s, struct pipe_context *pipe)
1052 {
1053 vl_csc_matrix csc_matrix;
1054
1055 assert(s);
1056
1057 memset(s, 0, sizeof(*s));
1058
1059 s->pipe = pipe;
1060
1061 s->clear_color.f[0] = s->clear_color.f[1] = 0.0f;
1062 s->clear_color.f[2] = s->clear_color.f[3] = 0.0f;
1063
1064 /*
1065 * Create our fragment shader's constant buffer
1066 * Const buffer contains the color conversion matrix and bias vectors
1067 */
1068 /* XXX: Create with IMMUTABLE/STATIC... although it does change every once in a long while... */
1069 s->csc_matrix = pipe_buffer_create
1070 (
1071 pipe->screen,
1072 PIPE_BIND_CONSTANT_BUFFER,
1073 PIPE_USAGE_STATIC,
1074 sizeof(csc_matrix)
1075 );
1076
1077 vl_compositor_clear_layers(s);
1078
1079 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, &csc_matrix);
1080 vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix);
1081
1082 return true;
1083 }
1084
1085 void
vl_compositor_cleanup_state(struct vl_compositor_state * s)1086 vl_compositor_cleanup_state(struct vl_compositor_state *s)
1087 {
1088 assert(s);
1089
1090 vl_compositor_clear_layers(s);
1091 pipe_resource_reference(&s->csc_matrix, NULL);
1092 }
1093