projects / mesa.git / blob
? search:


c084de9fb09fa5326b74e3a01bf478c22af53f92
[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 VMWARE 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 #include "util/u_upload_mgr.h"
37
38 #include "tgsi/tgsi_ureg.h"
39
40 #include "vl_csc.h"
41 #include "vl_types.h"
42 #include "vl_compositor.h"
43
44 #define MIN_DIRTY (0)
45 #define MAX_DIRTY (1 << 15)
46
47 enum VS_OUTPUT
48 {
49 VS_O_VPOS = 0,
50 VS_O_COLOR = 0,
51 VS_O_VTEX = 0,
52 VS_O_VTOP,
53 VS_O_VBOTTOM,
54 };
55
56 static void *
57 create_vert_shader(struct vl_compositor *c)
58 {
59 struct ureg_program *shader;
60 struct ureg_src vpos, vtex, color;
61 struct ureg_dst tmp;
62 struct ureg_dst o_vpos, o_vtex, o_color;
63 struct ureg_dst o_vtop, o_vbottom;
64
65 shader = ureg_create(PIPE_SHADER_VERTEX);
66 if (!shader)
67 return false;
68
69 vpos = ureg_DECL_vs_input(shader, 0);
70 vtex = ureg_DECL_vs_input(shader, 1);
71 color = ureg_DECL_vs_input(shader, 2);
72 tmp = ureg_DECL_temporary(shader);
73 o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);
74 o_color = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR);
75 o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX);
76 o_vtop = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP);
77 o_vbottom = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM);
78
79 /*
80 * o_vpos = vpos
81 * o_vtex = vtex
82 * o_color = color
83 */
84 ureg_MOV(shader, o_vpos, vpos);
85 ureg_MOV(shader, o_vtex, vtex);
86 ureg_MOV(shader, o_color, color);
87
88 /*
89 * tmp.x = vtex.w / 2
90 * tmp.y = vtex.w / 4
91 *
92 * o_vtop.x = vtex.x
93 * o_vtop.y = vtex.y * tmp.x + 0.25f
94 * o_vtop.z = vtex.y * tmp.y + 0.25f
95 * o_vtop.w = 1 / tmp.x
96 *
97 * o_vbottom.x = vtex.x
98 * o_vbottom.y = vtex.y * tmp.x - 0.25f
99 * o_vbottom.z = vtex.y * tmp.y - 0.25f
100 * o_vbottom.w = 1 / tmp.y
101 */
102 ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_X),
103 ureg_scalar(vtex, TGSI_SWIZZLE_W), ureg_imm1f(shader, 0.5f));
104 ureg_MUL(shader, ureg_writemask(tmp, TGSI_WRITEMASK_Y),
105 ureg_scalar(vtex, TGSI_SWIZZLE_W), ureg_imm1f(shader, 0.25f));
106
107 ureg_MOV(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_X), vtex);
108 ureg_MAD(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_Y), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
109 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), ureg_imm1f(shader, 0.25f));
110 ureg_MAD(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_Z), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
111 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y), ureg_imm1f(shader, 0.25f));
112 ureg_RCP(shader, ureg_writemask(o_vtop, TGSI_WRITEMASK_W),
113 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X));
114
115 ureg_MOV(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_X), vtex);
116 ureg_MAD(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_Y), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
117 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_X), ureg_imm1f(shader, -0.25f));
118 ureg_MAD(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_Z), ureg_scalar(vtex, TGSI_SWIZZLE_Y),
119 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y), ureg_imm1f(shader, -0.25f));
120 ureg_RCP(shader, ureg_writemask(o_vbottom, TGSI_WRITEMASK_W),
121 ureg_scalar(ureg_src(tmp), TGSI_SWIZZLE_Y));
122
123 ureg_END(shader);
124
125 return ureg_create_shader_and_destroy(shader, c->pipe);
126 }
127
128 static void
129 create_frag_shader_weave(struct ureg_program *shader, struct ureg_dst fragment)
130 {
131 struct ureg_src i_tc[2];
132 struct ureg_src sampler[3];
133 struct ureg_dst t_tc[2];
134 struct ureg_dst t_texel[2];
135 unsigned i, j;
136
137 i_tc[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP, TGSI_INTERPOLATE_LINEAR);
138 i_tc[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM, TGSI_INTERPOLATE_LINEAR);
139
140 for (i = 0; i < 3; ++i) {
141 sampler[i] = ureg_DECL_sampler(shader, i);
142 ureg_DECL_sampler_view(shader, i, TGSI_TEXTURE_2D_ARRAY,
143 TGSI_RETURN_TYPE_FLOAT,
144 TGSI_RETURN_TYPE_FLOAT,
145 TGSI_RETURN_TYPE_FLOAT,
146 TGSI_RETURN_TYPE_FLOAT);
147 }
148
149 for (i = 0; i < 2; ++i) {
150 t_tc[i] = ureg_DECL_temporary(shader);
151 t_texel[i] = ureg_DECL_temporary(shader);
152 }
153
154 /* calculate the texture offsets
155 * t_tc.x = i_tc.x
156 * t_tc.y = (round(i_tc.y - 0.5) + 0.5) / height * 2
157 */
158 for (i = 0; i < 2; ++i) {
159 ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_X), i_tc[i]);
160 ureg_ADD(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ),
161 i_tc[i], ureg_imm1f(shader, -0.5f));
162 ureg_ROUND(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ), ureg_src(t_tc[i]));
163 ureg_MOV(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_W),
164 ureg_imm1f(shader, i ? 1.0f : 0.0f));
165 ureg_ADD(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_YZ),
166 ureg_src(t_tc[i]), ureg_imm1f(shader, 0.5f));
167 ureg_MUL(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_Y),
168 ureg_src(t_tc[i]), ureg_scalar(i_tc[0], TGSI_SWIZZLE_W));
169 ureg_MUL(shader, ureg_writemask(t_tc[i], TGSI_WRITEMASK_Z),
170 ureg_src(t_tc[i]), ureg_scalar(i_tc[1], TGSI_SWIZZLE_W));
171 }
172
173 /* fetch the texels
174 * texel[0..1].x = tex(t_tc[0..1][0])
175 * texel[0..1].y = tex(t_tc[0..1][1])
176 * texel[0..1].z = tex(t_tc[0..1][2])
177 */
178 for (i = 0; i < 2; ++i)
179 for (j = 0; j < 3; ++j) {
180 struct ureg_src src = ureg_swizzle(ureg_src(t_tc[i]),
181 TGSI_SWIZZLE_X, j ? TGSI_SWIZZLE_Z : TGSI_SWIZZLE_Y, TGSI_SWIZZLE_W, TGSI_SWIZZLE_W);
182
183 ureg_TEX(shader, ureg_writemask(t_texel[i], TGSI_WRITEMASK_X << j),
184 TGSI_TEXTURE_2D_ARRAY, src, sampler[j]);
185 }
186
187 /* calculate linear interpolation factor
188 * factor = |round(i_tc.y) - i_tc.y| * 2
189 */
190 ureg_ROUND(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ), i_tc[0]);
191 ureg_ADD(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ),
192 ureg_src(t_tc[0]), ureg_negate(i_tc[0]));
193 ureg_MUL(shader, ureg_writemask(t_tc[0], TGSI_WRITEMASK_YZ),
194 ureg_abs(ureg_src(t_tc[0])), ureg_imm1f(shader, 2.0f));
195 ureg_LRP(shader, fragment, ureg_swizzle(ureg_src(t_tc[0]),
196 TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_Z, TGSI_SWIZZLE_Z),
197 ureg_src(t_texel[0]), ureg_src(t_texel[1]));
198
199 for (i = 0; i < 2; ++i) {
200 ureg_release_temporary(shader, t_texel[i]);
201 ureg_release_temporary(shader, t_tc[i]);
202 }
203 }
204
205 static void
206 create_frag_shader_csc(struct ureg_program *shader, struct ureg_dst texel,
207 struct ureg_dst fragment)
208 {
209 struct ureg_src csc[3];
210 struct ureg_src lumakey;
211 struct ureg_dst temp[2];
212 unsigned i;
213
214 for (i = 0; i < 3; ++i)
215 csc[i] = ureg_DECL_constant(shader, i);
216
217 lumakey = ureg_DECL_constant(shader, 3);
218
219 for (i = 0; i < 2; ++i)
220 temp[i] = ureg_DECL_temporary(shader);
221
222 ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_W),
223 ureg_imm1f(shader, 1.0f));
224
225 for (i = 0; i < 3; ++i)
226 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i],
227 ureg_src(texel));
228
229 ureg_MOV(shader, ureg_writemask(temp[0], TGSI_WRITEMASK_W),
230 ureg_scalar(ureg_src(texel), TGSI_SWIZZLE_Z));
231 ureg_SLE(shader, ureg_writemask(temp[1],TGSI_WRITEMASK_W),
232 ureg_src(temp[0]), ureg_scalar(lumakey, TGSI_SWIZZLE_X));
233 ureg_SGT(shader, ureg_writemask(temp[0],TGSI_WRITEMASK_W),
234 ureg_src(temp[0]), ureg_scalar(lumakey, TGSI_SWIZZLE_Y));
235 ureg_MAX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W),
236 ureg_src(temp[0]), ureg_src(temp[1]));
237
238 for (i = 0; i < 2; ++i)
239 ureg_release_temporary(shader, temp[i]);
240 }
241
242 static void
243 create_frag_shader_yuv(struct ureg_program *shader, struct ureg_dst texel)
244 {
245 struct ureg_src tc;
246 struct ureg_src sampler[3];
247 unsigned i;
248
249 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
250 for (i = 0; i < 3; ++i) {
251 sampler[i] = ureg_DECL_sampler(shader, i);
252 ureg_DECL_sampler_view(shader, i, TGSI_TEXTURE_2D_ARRAY,
253 TGSI_RETURN_TYPE_FLOAT,
254 TGSI_RETURN_TYPE_FLOAT,
255 TGSI_RETURN_TYPE_FLOAT,
256 TGSI_RETURN_TYPE_FLOAT);
257 }
258
259 /*
260 * texel.xyz = tex(tc, sampler[i])
261 */
262 for (i = 0; i < 3; ++i)
263 ureg_TEX(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), TGSI_TEXTURE_2D_ARRAY, tc, sampler[i]);
264 }
265
266 static void *
267 create_frag_shader_video_buffer(struct vl_compositor *c)
268 {
269 struct ureg_program *shader;
270 struct ureg_dst texel;
271 struct ureg_dst fragment;
272
273 shader = ureg_create(PIPE_SHADER_FRAGMENT);
274 if (!shader)
275 return false;
276
277 texel = ureg_DECL_temporary(shader);
278 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
279
280 create_frag_shader_yuv(shader, texel);
281 create_frag_shader_csc(shader, texel, fragment);
282
283 ureg_release_temporary(shader, texel);
284 ureg_END(shader);
285
286 return ureg_create_shader_and_destroy(shader, c->pipe);
287 }
288
289 static void *
290 create_frag_shader_weave_rgb(struct vl_compositor *c)
291 {
292 struct ureg_program *shader;
293 struct ureg_dst texel, fragment;
294
295 shader = ureg_create(PIPE_SHADER_FRAGMENT);
296 if (!shader)
297 return false;
298
299 texel = ureg_DECL_temporary(shader);
300 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
301
302 create_frag_shader_weave(shader, texel);
303 create_frag_shader_csc(shader, texel, fragment);
304
305 ureg_release_temporary(shader, texel);
306
307 ureg_END(shader);
308
309 return ureg_create_shader_and_destroy(shader, c->pipe);
310 }
311
312 static void *
313 create_frag_shader_deint_yuv(struct vl_compositor *c, bool y, bool w)
314 {
315 struct ureg_program *shader;
316 struct ureg_dst texel, fragment;
317
318 shader = ureg_create(PIPE_SHADER_FRAGMENT);
319 if (!shader)
320 return false;
321
322 texel = ureg_DECL_temporary(shader);
323 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
324
325 if (w)
326 create_frag_shader_weave(shader, texel);
327 else
328 create_frag_shader_yuv(shader, texel);
329
330 if (y)
331 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X), ureg_src(texel));
332 else
333 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XY),
334 ureg_swizzle(ureg_src(texel), TGSI_SWIZZLE_Y,
335 TGSI_SWIZZLE_Z, TGSI_SWIZZLE_W, TGSI_SWIZZLE_W));
336
337 ureg_release_temporary(shader, texel);
338
339 ureg_END(shader);
340
341 return ureg_create_shader_and_destroy(shader, c->pipe);
342 }
343
344 static void *
345 create_frag_shader_palette(struct vl_compositor *c, bool include_cc)
346 {
347 struct ureg_program *shader;
348 struct ureg_src csc[3];
349 struct ureg_src tc;
350 struct ureg_src sampler;
351 struct ureg_src palette;
352 struct ureg_dst texel;
353 struct ureg_dst fragment;
354 unsigned i;
355
356 shader = ureg_create(PIPE_SHADER_FRAGMENT);
357 if (!shader)
358 return false;
359
360 for (i = 0; include_cc && i < 3; ++i)
361 csc[i] = ureg_DECL_constant(shader, i);
362
363 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
364 sampler = ureg_DECL_sampler(shader, 0);
365 ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
366 TGSI_RETURN_TYPE_FLOAT,
367 TGSI_RETURN_TYPE_FLOAT,
368 TGSI_RETURN_TYPE_FLOAT,
369 TGSI_RETURN_TYPE_FLOAT);
370 palette = ureg_DECL_sampler(shader, 1);
371 ureg_DECL_sampler_view(shader, 1, TGSI_TEXTURE_1D,
372 TGSI_RETURN_TYPE_FLOAT,
373 TGSI_RETURN_TYPE_FLOAT,
374 TGSI_RETURN_TYPE_FLOAT,
375 TGSI_RETURN_TYPE_FLOAT);
376
377 texel = ureg_DECL_temporary(shader);
378 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
379
380 /*
381 * texel = tex(tc, sampler)
382 * fragment.xyz = tex(texel, palette) * csc
383 * fragment.a = texel.a
384 */
385 ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
386 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_src(texel));
387
388 if (include_cc) {
389 ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette);
390 for (i = 0; i < 3; ++i)
391 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));
392 } else {
393 ureg_TEX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XYZ),
394 TGSI_TEXTURE_1D, ureg_src(texel), palette);
395 }
396
397 ureg_release_temporary(shader, texel);
398 ureg_END(shader);
399
400 return ureg_create_shader_and_destroy(shader, c->pipe);
401 }
402
403 static void *
404 create_frag_shader_rgba(struct vl_compositor *c)
405 {
406 struct ureg_program *shader;
407 struct ureg_src tc, color, sampler;
408 struct ureg_dst texel, fragment;
409
410 shader = ureg_create(PIPE_SHADER_FRAGMENT);
411 if (!shader)
412 return false;
413
414 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
415 color = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR, TGSI_INTERPOLATE_LINEAR);
416 sampler = ureg_DECL_sampler(shader, 0);
417 ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,
418 TGSI_RETURN_TYPE_FLOAT,
419 TGSI_RETURN_TYPE_FLOAT,
420 TGSI_RETURN_TYPE_FLOAT,
421 TGSI_RETURN_TYPE_FLOAT);
422 texel = ureg_DECL_temporary(shader);
423 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
424
425 /*
426 * fragment = tex(tc, sampler)
427 */
428 ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
429 ureg_MUL(shader, fragment, ureg_src(texel), color);
430 ureg_END(shader);
431
432 return ureg_create_shader_and_destroy(shader, c->pipe);
433 }
434
435 static void *
436 create_frag_shader_rgb_yuv(struct vl_compositor *c, bool y)
437 {
438 struct ureg_program *shader;
439 struct ureg_src tc, sampler;
440 struct ureg_dst texel, fragment;
441
442 struct ureg_src csc[3];
443 unsigned i;
444
445 shader = ureg_create(PIPE_SHADER_FRAGMENT);
446 if (!shader)
447 return false;
448
449 for (i = 0; i < 3; ++i)
450 csc[i] = ureg_DECL_constant(shader, i);
451
452 sampler = ureg_DECL_sampler(shader, 0);
453 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);
454 texel = ureg_DECL_temporary(shader);
455 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
456
457 ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
458
459 if (y) {
460 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X), csc[0], ureg_src(texel));
461 } else {
462 for (i = 0; i < 2; ++i)
463 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i + 1], ureg_src(texel));
464 }
465
466 ureg_release_temporary(shader, texel);
467 ureg_END(shader);
468
469 return ureg_create_shader_and_destroy(shader, c->pipe);
470 }
471
472 static bool
473 init_shaders(struct vl_compositor *c)
474 {
475 assert(c);
476
477 c->vs = create_vert_shader(c);
478 if (!c->vs) {
479 debug_printf("Unable to create vertex shader.\n");
480 return false;
481 }
482
483 c->fs_video_buffer = create_frag_shader_video_buffer(c);
484 if (!c->fs_video_buffer) {
485 debug_printf("Unable to create YCbCr-to-RGB fragment shader.\n");
486 return false;
487 }
488
489 c->fs_weave_rgb = create_frag_shader_weave_rgb(c);
490 if (!c->fs_weave_rgb) {
491 debug_printf("Unable to create YCbCr-to-RGB weave fragment shader.\n");
492 return false;
493 }
494
495 c->fs_yuv.weave.y = create_frag_shader_deint_yuv(c, true, true);
496 c->fs_yuv.weave.uv = create_frag_shader_deint_yuv(c, false, true);
497 c->fs_yuv.bob.y = create_frag_shader_deint_yuv(c, true, false);
498 c->fs_yuv.bob.uv = create_frag_shader_deint_yuv(c, false, false);
499 if (!c->fs_yuv.weave.y || !c->fs_yuv.weave.uv ||
500 !c->fs_yuv.bob.y || !c->fs_yuv.bob.uv) {
501 debug_printf("Unable to create YCbCr i-to-YCbCr p deint fragment shader.\n");
502 return false;
503 }
504
505 c->fs_palette.yuv = create_frag_shader_palette(c, true);
506 if (!c->fs_palette.yuv) {
507 debug_printf("Unable to create YUV-Palette-to-RGB fragment shader.\n");
508 return false;
509 }
510
511 c->fs_palette.rgb = create_frag_shader_palette(c, false);
512 if (!c->fs_palette.rgb) {
513 debug_printf("Unable to create RGB-Palette-to-RGB fragment shader.\n");
514 return false;
515 }
516
517 c->fs_rgba = create_frag_shader_rgba(c);
518 if (!c->fs_rgba) {
519 debug_printf("Unable to create RGB-to-RGB fragment shader.\n");
520 return false;
521 }
522
523 c->fs_rgb_yuv.y = create_frag_shader_rgb_yuv(c, true);
524 c->fs_rgb_yuv.uv = create_frag_shader_rgb_yuv(c, false);
525 if (!c->fs_rgb_yuv.y || !c->fs_rgb_yuv.uv) {
526 debug_printf("Unable to create RGB-to-YUV fragment shader.\n");
527 return false;
528 }
529
530 return true;
531 }
532
533 static void cleanup_shaders(struct vl_compositor *c)
534 {
535 assert(c);
536
537 c->pipe->delete_vs_state(c->pipe, c->vs);
538 c->pipe->delete_fs_state(c->pipe, c->fs_video_buffer);
539 c->pipe->delete_fs_state(c->pipe, c->fs_weave_rgb);
540 c->pipe->delete_fs_state(c->pipe, c->fs_yuv.weave.y);
541 c->pipe->delete_fs_state(c->pipe, c->fs_yuv.weave.uv);
542 c->pipe->delete_fs_state(c->pipe, c->fs_yuv.bob.y);
543 c->pipe->delete_fs_state(c->pipe, c->fs_yuv.bob.uv);
544 c->pipe->delete_fs_state(c->pipe, c->fs_palette.yuv);
545 c->pipe->delete_fs_state(c->pipe, c->fs_palette.rgb);
546 c->pipe->delete_fs_state(c->pipe, c->fs_rgba);
547 c->pipe->delete_fs_state(c->pipe, c->fs_rgb_yuv.y);
548 c->pipe->delete_fs_state(c->pipe, c->fs_rgb_yuv.uv);
549 }
550
551 static bool
552 init_pipe_state(struct vl_compositor *c)
553 {
554 struct pipe_rasterizer_state rast;
555 struct pipe_sampler_state sampler;
556 struct pipe_blend_state blend;
557 struct pipe_depth_stencil_alpha_state dsa;
558 unsigned i;
559
560 assert(c);
561
562 c->fb_state.nr_cbufs = 1;
563 c->fb_state.zsbuf = NULL;
564
565 memset(&sampler, 0, sizeof(sampler));
566 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
567 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
568 sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
569 sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
570 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
571 sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
572 sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
573 sampler.compare_func = PIPE_FUNC_ALWAYS;
574 sampler.normalized_coords = 1;
575
576 c->sampler_linear = c->pipe->create_sampler_state(c->pipe, &sampler);
577
578 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
579 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
580 c->sampler_nearest = c->pipe->create_sampler_state(c->pipe, &sampler);
581
582 memset(&blend, 0, sizeof blend);
583 blend.independent_blend_enable = 0;
584 blend.rt[0].blend_enable = 0;
585 blend.logicop_enable = 0;
586 blend.logicop_func = PIPE_LOGICOP_CLEAR;
587 blend.rt[0].colormask = PIPE_MASK_RGBA;
588 blend.dither = 0;
589 c->blend_clear = c->pipe->create_blend_state(c->pipe, &blend);
590
591 blend.rt[0].blend_enable = 1;
592 blend.rt[0].rgb_func = PIPE_BLEND_ADD;
593 blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
594 blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
595 blend.rt[0].alpha_func = PIPE_BLEND_ADD;
596 blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
597 blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
598 c->blend_add = c->pipe->create_blend_state(c->pipe, &blend);
599
600 memset(&rast, 0, sizeof rast);
601 rast.flatshade = 0;
602 rast.front_ccw = 1;
603 rast.cull_face = PIPE_FACE_NONE;
604 rast.fill_back = PIPE_POLYGON_MODE_FILL;
605 rast.fill_front = PIPE_POLYGON_MODE_FILL;
606 rast.scissor = 1;
607 rast.line_width = 1;
608 rast.point_size_per_vertex = 1;
609 rast.offset_units = 1;
610 rast.offset_scale = 1;
611 rast.half_pixel_center = 1;
612 rast.bottom_edge_rule = 1;
613 rast.depth_clip = 1;
614
615 c->rast = c->pipe->create_rasterizer_state(c->pipe, &rast);
616
617 memset(&dsa, 0, sizeof dsa);
618 dsa.depth.enabled = 0;
619 dsa.depth.writemask = 0;
620 dsa.depth.func = PIPE_FUNC_ALWAYS;
621 for (i = 0; i < 2; ++i) {
622 dsa.stencil[i].enabled = 0;
623 dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
624 dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
625 dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
626 dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
627 dsa.stencil[i].valuemask = 0;
628 dsa.stencil[i].writemask = 0;
629 }
630 dsa.alpha.enabled = 0;
631 dsa.alpha.func = PIPE_FUNC_ALWAYS;
632 dsa.alpha.ref_value = 0;
633 c->dsa = c->pipe->create_depth_stencil_alpha_state(c->pipe, &dsa);
634 c->pipe->bind_depth_stencil_alpha_state(c->pipe, c->dsa);
635
636 return true;
637 }
638
639 static void cleanup_pipe_state(struct vl_compositor *c)
640 {
641 assert(c);
642
643 /* Asserted in softpipe_delete_fs_state() for some reason */
644 c->pipe->bind_vs_state(c->pipe, NULL);
645 c->pipe->bind_fs_state(c->pipe, NULL);
646
647 c->pipe->delete_depth_stencil_alpha_state(c->pipe, c->dsa);
648 c->pipe->delete_sampler_state(c->pipe, c->sampler_linear);
649 c->pipe->delete_sampler_state(c->pipe, c->sampler_nearest);
650 c->pipe->delete_blend_state(c->pipe, c->blend_clear);
651 c->pipe->delete_blend_state(c->pipe, c->blend_add);
652 c->pipe->delete_rasterizer_state(c->pipe, c->rast);
653 }
654
655 static bool
656 init_buffers(struct vl_compositor *c)
657 {
658 struct pipe_vertex_element vertex_elems[3];
659
660 assert(c);
661
662 /*
663 * Create our vertex buffer and vertex buffer elements
664 */
665 c->vertex_buf.stride = sizeof(struct vertex2f) + sizeof(struct vertex4f) * 2;
666 c->vertex_buf.buffer_offset = 0;
667 c->vertex_buf.buffer.resource = NULL;
668 c->vertex_buf.is_user_buffer = false;
669
670 vertex_elems[0].src_offset = 0;
671 vertex_elems[0].instance_divisor = 0;
672 vertex_elems[0].vertex_buffer_index = 0;
673 vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
674 vertex_elems[1].src_offset = sizeof(struct vertex2f);
675 vertex_elems[1].instance_divisor = 0;
676 vertex_elems[1].vertex_buffer_index = 0;
677 vertex_elems[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
678 vertex_elems[2].src_offset = sizeof(struct vertex2f) + sizeof(struct vertex4f);
679 vertex_elems[2].instance_divisor = 0;
680 vertex_elems[2].vertex_buffer_index = 0;
681 vertex_elems[2].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
682 c->vertex_elems_state = c->pipe->create_vertex_elements_state(c->pipe, 3, vertex_elems);
683
684 return true;
685 }
686
687 static void
688 cleanup_buffers(struct vl_compositor *c)
689 {
690 assert(c);
691
692 c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems_state);
693 pipe_resource_reference(&c->vertex_buf.buffer.resource, NULL);
694 }
695
696 static inline struct u_rect
697 default_rect(struct vl_compositor_layer *layer)
698 {
699 struct pipe_resource *res = layer->sampler_views[0]->texture;
700 struct u_rect rect = { 0, res->width0, 0, res->height0 * res->array_size };
701 return rect;
702 }
703
704 static inline struct vertex2f
705 calc_topleft(struct vertex2f size, struct u_rect rect)
706 {
707 struct vertex2f res = { rect.x0 / size.x, rect.y0 / size.y };
708 return res;
709 }
710
711 static inline struct vertex2f
712 calc_bottomright(struct vertex2f size, struct u_rect rect)
713 {
714 struct vertex2f res = { rect.x1 / size.x, rect.y1 / size.y };
715 return res;
716 }
717
718 static inline void
719 calc_src_and_dst(struct vl_compositor_layer *layer, unsigned width, unsigned height,
720 struct u_rect src, struct u_rect dst)
721 {
722 struct vertex2f size = { width, height };
723
724 layer->src.tl = calc_topleft(size, src);
725 layer->src.br = calc_bottomright(size, src);
726 layer->dst.tl = calc_topleft(size, dst);
727 layer->dst.br = calc_bottomright(size, dst);
728 layer->zw.x = 0.0f;
729 layer->zw.y = size.y;
730 }
731
732 static void
733 gen_rect_verts(struct vertex2f *vb, struct vl_compositor_layer *layer)
734 {
735 struct vertex2f tl, tr, br, bl;
736
737 assert(vb && layer);
738
739 switch (layer->rotate) {
740 default:
741 case VL_COMPOSITOR_ROTATE_0:
742 tl = layer->dst.tl;
743 tr.x = layer->dst.br.x;
744 tr.y = layer->dst.tl.y;
745 br = layer->dst.br;
746 bl.x = layer->dst.tl.x;
747 bl.y = layer->dst.br.y;
748 break;
749 case VL_COMPOSITOR_ROTATE_90:
750 tl.x = layer->dst.br.x;
751 tl.y = layer->dst.tl.y;
752 tr = layer->dst.br;
753 br.x = layer->dst.tl.x;
754 br.y = layer->dst.br.y;
755 bl = layer->dst.tl;
756 break;
757 case VL_COMPOSITOR_ROTATE_180:
758 tl = layer->dst.br;
759 tr.x = layer->dst.tl.x;
760 tr.y = layer->dst.br.y;
761 br = layer->dst.tl;
762 bl.x = layer->dst.br.x;
763 bl.y = layer->dst.tl.y;
764 break;
765 case VL_COMPOSITOR_ROTATE_270:
766 tl.x = layer->dst.tl.x;
767 tl.y = layer->dst.br.y;
768 tr = layer->dst.tl;
769 br.x = layer->dst.br.x;
770 br.y = layer->dst.tl.y;
771 bl = layer->dst.br;
772 break;
773 }
774
775 vb[ 0].x = tl.x;
776 vb[ 0].y = tl.y;
777 vb[ 1].x = layer->src.tl.x;
778 vb[ 1].y = layer->src.tl.y;
779 vb[ 2] = layer->zw;
780 vb[ 3].x = layer->colors[0].x;
781 vb[ 3].y = layer->colors[0].y;
782 vb[ 4].x = layer->colors[0].z;
783 vb[ 4].y = layer->colors[0].w;
784
785 vb[ 5].x = tr.x;
786 vb[ 5].y = tr.y;
787 vb[ 6].x = layer->src.br.x;
788 vb[ 6].y = layer->src.tl.y;
789 vb[ 7] = layer->zw;
790 vb[ 8].x = layer->colors[1].x;
791 vb[ 8].y = layer->colors[1].y;
792 vb[ 9].x = layer->colors[1].z;
793 vb[ 9].y = layer->colors[1].w;
794
795 vb[10].x = br.x;
796 vb[10].y = br.y;
797 vb[11].x = layer->src.br.x;
798 vb[11].y = layer->src.br.y;
799 vb[12] = layer->zw;
800 vb[13].x = layer->colors[2].x;
801 vb[13].y = layer->colors[2].y;
802 vb[14].x = layer->colors[2].z;
803 vb[14].y = layer->colors[2].w;
804
805 vb[15].x = bl.x;
806 vb[15].y = bl.y;
807 vb[16].x = layer->src.tl.x;
808 vb[16].y = layer->src.br.y;
809 vb[17] = layer->zw;
810 vb[18].x = layer->colors[3].x;
811 vb[18].y = layer->colors[3].y;
812 vb[19].x = layer->colors[3].z;
813 vb[19].y = layer->colors[3].w;
814 }
815
816 static inline struct u_rect
817 calc_drawn_area(struct vl_compositor_state *s, struct vl_compositor_layer *layer)
818 {
819 struct vertex2f tl, br;
820 struct u_rect result;
821
822 assert(s && layer);
823
824 // rotate
825 switch (layer->rotate) {
826 default:
827 case VL_COMPOSITOR_ROTATE_0:
828 tl = layer->dst.tl;
829 br = layer->dst.br;
830 break;
831 case VL_COMPOSITOR_ROTATE_90:
832 tl.x = layer->dst.br.x;
833 tl.y = layer->dst.tl.y;
834 br.x = layer->dst.tl.x;
835 br.y = layer->dst.br.y;
836 break;
837 case VL_COMPOSITOR_ROTATE_180:
838 tl = layer->dst.br;
839 br = layer->dst.tl;
840 break;
841 case VL_COMPOSITOR_ROTATE_270:
842 tl.x = layer->dst.tl.x;
843 tl.y = layer->dst.br.y;
844 br.x = layer->dst.br.x;
845 br.y = layer->dst.tl.y;
846 break;
847 }
848
849 // scale
850 result.x0 = tl.x * layer->viewport.scale[0] + layer->viewport.translate[0];
851 result.y0 = tl.y * layer->viewport.scale[1] + layer->viewport.translate[1];
852 result.x1 = br.x * layer->viewport.scale[0] + layer->viewport.translate[0];
853 result.y1 = br.y * layer->viewport.scale[1] + layer->viewport.translate[1];
854
855 // and clip
856 result.x0 = MAX2(result.x0, s->scissor.minx);
857 result.y0 = MAX2(result.y0, s->scissor.miny);
858 result.x1 = MIN2(result.x1, s->scissor.maxx);
859 result.y1 = MIN2(result.y1, s->scissor.maxy);
860 return result;
861 }
862
863 static void
864 gen_vertex_data(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty)
865 {
866 struct vertex2f *vb;
867 unsigned i;
868
869 assert(c);
870
871 /* Allocate new memory for vertices. */
872 u_upload_alloc(c->pipe->stream_uploader, 0,
873 c->vertex_buf.stride * VL_COMPOSITOR_MAX_LAYERS * 4, /* size */
874 4, /* alignment */
875 &c->vertex_buf.buffer_offset, &c->vertex_buf.buffer.resource,
876 (void**)&vb);
877
878 for (i = 0; i < VL_COMPOSITOR_MAX_LAYERS; i++) {
879 if (s->used_layers & (1 << i)) {
880 struct vl_compositor_layer *layer = &s->layers[i];
881 gen_rect_verts(vb, layer);
882 vb += 20;
883
884 if (!layer->viewport_valid) {
885 layer->viewport.scale[0] = c->fb_state.width;
886 layer->viewport.scale[1] = c->fb_state.height;
887 layer->viewport.translate[0] = 0;
888 layer->viewport.translate[1] = 0;
889 }
890
891 if (dirty && layer->clearing) {
892 struct u_rect drawn = calc_drawn_area(s, layer);
893 if (
894 dirty->x0 >= drawn.x0 &&
895 dirty->y0 >= drawn.y0 &&
896 dirty->x1 <= drawn.x1 &&
897 dirty->y1 <= drawn.y1) {
898
899 // We clear the dirty area anyway, no need for clear_render_target
900 dirty->x0 = dirty->y0 = MAX_DIRTY;
901 dirty->x1 = dirty->y1 = MIN_DIRTY;
902 }
903 }
904 }
905 }
906
907 u_upload_unmap(c->pipe->stream_uploader);
908 }
909
910 static void
911 draw_layers(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty)
912 {
913 unsigned vb_index, i;
914
915 assert(c);
916
917 for (i = 0, vb_index = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
918 if (s->used_layers & (1 << i)) {
919 struct vl_compositor_layer *layer = &s->layers[i];
920 struct pipe_sampler_view **samplers = &layer->sampler_views[0];
921 unsigned num_sampler_views = !samplers[1] ? 1 : !samplers[2] ? 2 : 3;
922 void *blend = layer->blend ? layer->blend : i ? c->blend_add : c->blend_clear;
923
924 c->pipe->bind_blend_state(c->pipe, blend);
925 c->pipe->set_viewport_states(c->pipe, 0, 1, &layer->viewport);
926 c->pipe->bind_fs_state(c->pipe, layer->fs);
927 c->pipe->bind_sampler_states(c->pipe, PIPE_SHADER_FRAGMENT, 0,
928 num_sampler_views, layer->samplers);
929 c->pipe->set_sampler_views(c->pipe, PIPE_SHADER_FRAGMENT, 0,
930 num_sampler_views, samplers);
931
932 util_draw_arrays(c->pipe, PIPE_PRIM_QUADS, vb_index * 4, 4);
933 vb_index++;
934
935 if (dirty) {
936 // Remember the currently drawn area as dirty for the next draw command
937 struct u_rect drawn = calc_drawn_area(s, layer);
938 dirty->x0 = MIN2(drawn.x0, dirty->x0);
939 dirty->y0 = MIN2(drawn.y0, dirty->y0);
940 dirty->x1 = MAX2(drawn.x1, dirty->x1);
941 dirty->y1 = MAX2(drawn.y1, dirty->y1);
942 }
943 }
944 }
945 }
946
947 static void
948 set_yuv_layer(struct vl_compositor_state *s, struct vl_compositor *c,
949 unsigned layer, struct pipe_video_buffer *buffer,
950 struct u_rect *src_rect, struct u_rect *dst_rect,
951 bool y, enum vl_compositor_deinterlace deinterlace)
952 {
953 struct pipe_sampler_view **sampler_views;
954 float half_a_line;
955 unsigned i;
956
957 assert(s && c && buffer);
958
959 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
960
961 s->used_layers |= 1 << layer;
962 sampler_views = buffer->get_sampler_view_components(buffer);
963 for (i = 0; i < 3; ++i) {
964 s->layers[layer].samplers[i] = c->sampler_linear;
965 pipe_sampler_view_reference(&s->layers[layer].sampler_views[i], sampler_views[i]);
966 }
967
968 calc_src_and_dst(&s->layers[layer], buffer->width, buffer->height,
969 src_rect ? *src_rect : default_rect(&s->layers[layer]),
970 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
971
972 half_a_line = 0.5f / s->layers[layer].zw.y;
973
974 switch(deinterlace) {
975 case VL_COMPOSITOR_BOB_TOP:
976 s->layers[layer].zw.x = 0.0f;
977 s->layers[layer].src.tl.y += half_a_line;
978 s->layers[layer].src.br.y += half_a_line;
979 s->layers[layer].fs = (y) ? c->fs_yuv.bob.y : c->fs_yuv.bob.uv;
980 break;
981
982 case VL_COMPOSITOR_BOB_BOTTOM:
983 s->layers[layer].zw.x = 1.0f;
984 s->layers[layer].src.tl.y -= half_a_line;
985 s->layers[layer].src.br.y -= half_a_line;
986 s->layers[layer].fs = (y) ? c->fs_yuv.bob.y : c->fs_yuv.bob.uv;
987 break;
988
989 default:
990 s->layers[layer].fs = (y) ? c->fs_yuv.weave.y : c->fs_yuv.weave.uv;
991 break;
992 }
993 }
994
995 void
996 vl_compositor_reset_dirty_area(struct u_rect *dirty)
997 {
998 assert(dirty);
999
1000 dirty->x0 = dirty->y0 = MIN_DIRTY;
1001 dirty->x1 = dirty->y1 = MAX_DIRTY;
1002 }
1003
1004 void
1005 vl_compositor_set_clear_color(struct vl_compositor_state *s, union pipe_color_union *color)
1006 {
1007 assert(s);
1008 assert(color);
1009
1010 s->clear_color = *color;
1011 }
1012
1013 void
1014 vl_compositor_get_clear_color(struct vl_compositor_state *s, union pipe_color_union *color)
1015 {
1016 assert(s);
1017 assert(color);
1018
1019 *color = s->clear_color;
1020 }
1021
1022 void
1023 vl_compositor_clear_layers(struct vl_compositor_state *s)
1024 {
1025 unsigned i, j;
1026
1027 assert(s);
1028
1029 s->used_layers = 0;
1030 for ( i = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
1031 struct vertex4f v_one = { 1.0f, 1.0f, 1.0f, 1.0f };
1032 s->layers[i].clearing = i ? false : true;
1033 s->layers[i].blend = NULL;
1034 s->layers[i].fs = NULL;
1035 s->layers[i].viewport.scale[2] = 1;
1036 s->layers[i].viewport.translate[2] = 0;
1037 s->layers[i].rotate = VL_COMPOSITOR_ROTATE_0;
1038
1039 for ( j = 0; j < 3; j++)
1040 pipe_sampler_view_reference(&s->layers[i].sampler_views[j], NULL);
1041 for ( j = 0; j < 4; ++j)
1042 s->layers[i].colors[j] = v_one;
1043 }
1044 }
1045
1046 void
1047 vl_compositor_cleanup(struct vl_compositor *c)
1048 {
1049 assert(c);
1050
1051 cleanup_buffers(c);
1052 cleanup_shaders(c);
1053 cleanup_pipe_state(c);
1054 }
1055
1056 bool
1057 vl_compositor_set_csc_matrix(struct vl_compositor_state *s,
1058 vl_csc_matrix const *matrix,
1059 float luma_min, float luma_max)
1060 {
1061 struct pipe_transfer *buf_transfer;
1062
1063 assert(s);
1064
1065 float *ptr = pipe_buffer_map(s->pipe, s->csc_matrix,
1066 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
1067 &buf_transfer);
1068
1069 if (!ptr)
1070 return false;
1071
1072 memcpy(ptr, matrix, sizeof(vl_csc_matrix));
1073
1074 ptr += sizeof(vl_csc_matrix)/sizeof(float);
1075 ptr[0] = luma_min;
1076 ptr[1] = luma_max;
1077
1078 pipe_buffer_unmap(s->pipe, buf_transfer);
1079
1080 return true;
1081 }
1082
1083 void
1084 vl_compositor_set_dst_clip(struct vl_compositor_state *s, struct u_rect *dst_clip)
1085 {
1086 assert(s);
1087
1088 s->scissor_valid = dst_clip != NULL;
1089 if (dst_clip) {
1090 s->scissor.minx = dst_clip->x0;
1091 s->scissor.miny = dst_clip->y0;
1092 s->scissor.maxx = dst_clip->x1;
1093 s->scissor.maxy = dst_clip->y1;
1094 }
1095 }
1096
1097 void
1098 vl_compositor_set_layer_blend(struct vl_compositor_state *s,
1099 unsigned layer, void *blend,
1100 bool is_clearing)
1101 {
1102 assert(s && blend);
1103
1104 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
1105
1106 s->layers[layer].clearing = is_clearing;
1107 s->layers[layer].blend = blend;
1108 }
1109
1110 void
1111 vl_compositor_set_layer_dst_area(struct vl_compositor_state *s,
1112 unsigned layer, struct u_rect *dst_area)
1113 {
1114 assert(s);
1115
1116 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
1117
1118 s->layers[layer].viewport_valid = dst_area != NULL;
1119 if (dst_area) {
1120 s->layers[layer].viewport.scale[0] = dst_area->x1 - dst_area->x0;
1121 s->layers[layer].viewport.scale[1] = dst_area->y1 - dst_area->y0;
1122 s->layers[layer].viewport.translate[0] = dst_area->x0;
1123 s->layers[layer].viewport.translate[1] = dst_area->y0;
1124 }
1125 }
1126
1127 void
1128 vl_compositor_set_buffer_layer(struct vl_compositor_state *s,
1129 struct vl_compositor *c,
1130 unsigned layer,
1131 struct pipe_video_buffer *buffer,
1132 struct u_rect *src_rect,
1133 struct u_rect *dst_rect,
1134 enum vl_compositor_deinterlace deinterlace)
1135 {
1136 struct pipe_sampler_view **sampler_views;
1137 unsigned i;
1138
1139 assert(s && c && buffer);
1140
1141 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
1142
1143 s->used_layers |= 1 << layer;
1144 sampler_views = buffer->get_sampler_view_components(buffer);
1145 for (i = 0; i < 3; ++i) {
1146 s->layers[layer].samplers[i] = c->sampler_linear;
1147 pipe_sampler_view_reference(&s->layers[layer].sampler_views[i], sampler_views[i]);
1148 }
1149
1150 calc_src_and_dst(&s->layers[layer], buffer->width, buffer->height,
1151 src_rect ? *src_rect : default_rect(&s->layers[layer]),
1152 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
1153
1154 if (buffer->interlaced) {
1155 float half_a_line = 0.5f / s->layers[layer].zw.y;
1156 switch(deinterlace) {
1157 case VL_COMPOSITOR_WEAVE:
1158 s->layers[layer].fs = c->fs_weave_rgb;
1159 break;
1160
1161 case VL_COMPOSITOR_BOB_TOP:
1162 s->layers[layer].zw.x = 0.0f;
1163 s->layers[layer].src.tl.y += half_a_line;
1164 s->layers[layer].src.br.y += half_a_line;
1165 s->layers[layer].fs = c->fs_video_buffer;
1166 break;
1167
1168 case VL_COMPOSITOR_BOB_BOTTOM:
1169 s->layers[layer].zw.x = 1.0f;
1170 s->layers[layer].src.tl.y -= half_a_line;
1171 s->layers[layer].src.br.y -= half_a_line;
1172 s->layers[layer].fs = c->fs_video_buffer;
1173 break;
1174 }
1175
1176 } else
1177 s->layers[layer].fs = c->fs_video_buffer;
1178 }
1179
1180 void
1181 vl_compositor_set_palette_layer(struct vl_compositor_state *s,
1182 struct vl_compositor *c,
1183 unsigned layer,
1184 struct pipe_sampler_view *indexes,
1185 struct pipe_sampler_view *palette,
1186 struct u_rect *src_rect,
1187 struct u_rect *dst_rect,
1188 bool include_color_conversion)
1189 {
1190 assert(s && c && indexes && palette);
1191
1192 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
1193
1194 s->used_layers |= 1 << layer;
1195
1196 s->layers[layer].fs = include_color_conversion ?
1197 c->fs_palette.yuv : c->fs_palette.rgb;
1198
1199 s->layers[layer].samplers[0] = c->sampler_linear;
1200 s->layers[layer].samplers[1] = c->sampler_nearest;
1201 s->layers[layer].samplers[2] = NULL;
1202 pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], indexes);
1203 pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], palette);
1204 pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
1205 calc_src_and_dst(&s->layers[layer], indexes->texture->width0, indexes->texture->height0,
1206 src_rect ? *src_rect : default_rect(&s->layers[layer]),
1207 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
1208 }
1209
1210 void
1211 vl_compositor_set_rgba_layer(struct vl_compositor_state *s,
1212 struct vl_compositor *c,
1213 unsigned layer,
1214 struct pipe_sampler_view *rgba,
1215 struct u_rect *src_rect,
1216 struct u_rect *dst_rect,
1217 struct vertex4f *colors)
1218 {
1219 unsigned i;
1220
1221 assert(s && c && rgba);
1222
1223 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
1224
1225 s->used_layers |= 1 << layer;
1226 s->layers[layer].fs = c->fs_rgba;
1227 s->layers[layer].samplers[0] = c->sampler_linear;
1228 s->layers[layer].samplers[1] = NULL;
1229 s->layers[layer].samplers[2] = NULL;
1230 pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], rgba);
1231 pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], NULL);
1232 pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
1233 calc_src_and_dst(&s->layers[layer], rgba->texture->width0, rgba->texture->height0,
1234 src_rect ? *src_rect : default_rect(&s->layers[layer]),
1235 dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
1236
1237 if (colors)
1238 for (i = 0; i < 4; ++i)
1239 s->layers[layer].colors[i] = colors[i];
1240 }
1241
1242 void
1243 vl_compositor_set_layer_rotation(struct vl_compositor_state *s,
1244 unsigned layer,
1245 enum vl_compositor_rotation rotate)
1246 {
1247 assert(s);
1248 assert(layer < VL_COMPOSITOR_MAX_LAYERS);
1249 s->layers[layer].rotate = rotate;
1250 }
1251
1252 void
1253 vl_compositor_yuv_deint_full(struct vl_compositor_state *s,
1254 struct vl_compositor *c,
1255 struct pipe_video_buffer *src,
1256 struct pipe_video_buffer *dst,
1257 struct u_rect *src_rect,
1258 struct u_rect *dst_rect,
1259 enum vl_compositor_deinterlace deinterlace)
1260 {
1261 struct pipe_surface **dst_surfaces;
1262
1263 dst_surfaces = dst->get_surfaces(dst);
1264 vl_compositor_clear_layers(s);
1265
1266 set_yuv_layer(s, c, 0, src, src_rect, NULL, true, deinterlace);
1267 vl_compositor_set_layer_dst_area(s, 0, dst_rect);
1268 vl_compositor_render(s, c, dst_surfaces[0], NULL, false);
1269
1270 if (dst_rect) {
1271 dst_rect->x1 /= 2;
1272 dst_rect->y1 /= 2;
1273 }
1274
1275 set_yuv_layer(s, c, 0, src, src_rect, NULL, false, deinterlace);
1276 vl_compositor_set_layer_dst_area(s, 0, dst_rect);
1277 vl_compositor_render(s, c, dst_surfaces[1], NULL, false);
1278
1279 s->pipe->flush(s->pipe, NULL, 0);
1280 }
1281
1282 void
1283 vl_compositor_render(struct vl_compositor_state *s,
1284 struct vl_compositor *c,
1285 struct pipe_surface *dst_surface,
1286 struct u_rect *dirty_area,
1287 bool clear_dirty)
1288 {
1289 assert(c);
1290 assert(dst_surface);
1291
1292 c->fb_state.width = dst_surface->width;
1293 c->fb_state.height = dst_surface->height;
1294 c->fb_state.cbufs[0] = dst_surface;
1295
1296 if (!s->scissor_valid) {
1297 s->scissor.minx = 0;
1298 s->scissor.miny = 0;
1299 s->scissor.maxx = dst_surface->width;
1300 s->scissor.maxy = dst_surface->height;
1301 }
1302 c->pipe->set_scissor_states(c->pipe, 0, 1, &s->scissor);
1303
1304 gen_vertex_data(c, s, dirty_area);
1305
1306 if (clear_dirty && dirty_area &&
1307 (dirty_area->x0 < dirty_area->x1 || dirty_area->y0 < dirty_area->y1)) {
1308
1309 c->pipe->clear_render_target(c->pipe, dst_surface, &s->clear_color,
1310 0, 0, dst_surface->width, dst_surface->height, false);
1311 dirty_area->x0 = dirty_area->y0 = MAX_DIRTY;
1312 dirty_area->x1 = dirty_area->y1 = MIN_DIRTY;
1313 }
1314
1315 c->pipe->set_framebuffer_state(c->pipe, &c->fb_state);
1316 c->pipe->bind_vs_state(c->pipe, c->vs);
1317 c->pipe->set_vertex_buffers(c->pipe, 0, 1, &c->vertex_buf);
1318 c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state);
1319 pipe_set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, s->csc_matrix);
1320 c->pipe->bind_rasterizer_state(c->pipe, c->rast);
1321
1322 draw_layers(c, s, dirty_area);
1323 }
1324
1325 bool
1326 vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe)
1327 {
1328 assert(c);
1329
1330 memset(c, 0, sizeof(*c));
1331
1332 c->pipe = pipe;
1333
1334 if (!init_pipe_state(c)) {
1335 return false;
1336 }
1337
1338 if (!init_shaders(c)) {
1339 cleanup_pipe_state(c);
1340 return false;
1341 }
1342
1343 if (!init_buffers(c)) {
1344 cleanup_shaders(c);
1345 cleanup_pipe_state(c);
1346 return false;
1347 }
1348
1349 return true;
1350 }
1351
1352 bool
1353 vl_compositor_init_state(struct vl_compositor_state *s, struct pipe_context *pipe)
1354 {
1355 vl_csc_matrix csc_matrix;
1356
1357 assert(s);
1358
1359 memset(s, 0, sizeof(*s));
1360
1361 s->pipe = pipe;
1362
1363 s->clear_color.f[0] = s->clear_color.f[1] = 0.0f;
1364 s->clear_color.f[2] = s->clear_color.f[3] = 0.0f;
1365
1366 /*
1367 * Create our fragment shader's constant buffer
1368 * Const buffer contains the color conversion matrix and bias vectors
1369 */
1370 /* XXX: Create with IMMUTABLE/STATIC... although it does change every once in a long while... */
1371 s->csc_matrix = pipe_buffer_create
1372 (
1373 pipe->screen,
1374 PIPE_BIND_CONSTANT_BUFFER,
1375 PIPE_USAGE_DEFAULT,
1376 sizeof(csc_matrix) + 2*sizeof(float)
1377 );
1378
1379 if (!s->csc_matrix)
1380 return false;
1381
1382 vl_compositor_clear_layers(s);
1383
1384 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, &csc_matrix);
1385 if (!vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix, 1.0f, 0.0f))
1386 return false;
1387
1388 return true;
1389 }
1390
1391 void
1392 vl_compositor_cleanup_state(struct vl_compositor_state *s)
1393 {
1394 assert(s);
1395
1396 vl_compositor_clear_layers(s);
1397 pipe_resource_reference(&s->csc_matrix, NULL);
1398 }