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