vl_compositor.c revision 02e191cb6aa13286fff956a7929959d7cee7241d
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 43typedef float csc_matrix[16]; 44 45static void * 46create_vert_shader(struct vl_compositor *c) 47{ 48 struct ureg_program *shader; 49 struct ureg_src vpos, vtex; 50 struct ureg_dst o_vpos, o_vtex; 51 52 shader = ureg_create(TGSI_PROCESSOR_VERTEX); 53 if (!shader) 54 return false; 55 56 vpos = ureg_DECL_vs_input(shader, 0); 57 vtex = ureg_DECL_vs_input(shader, 1); 58 o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, 0); 59 o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, 1); 60 61 /* 62 * o_vpos = vpos 63 * o_vtex = vtex 64 */ 65 ureg_MOV(shader, o_vpos, vpos); 66 ureg_MOV(shader, o_vtex, vtex); 67 68 ureg_END(shader); 69 70 return ureg_create_shader_and_destroy(shader, c->pipe); 71} 72 73static void * 74create_frag_shader_video_buffer(struct vl_compositor *c) 75{ 76 struct ureg_program *shader; 77 struct ureg_src tc; 78 struct ureg_src csc[3]; 79 struct ureg_src sampler[3]; 80 struct ureg_dst texel; 81 struct ureg_dst fragment; 82 unsigned i; 83 84 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT); 85 if (!shader) 86 return false; 87 88 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, 1, TGSI_INTERPOLATE_LINEAR); 89 for (i = 0; i < 3; ++i) { 90 csc[i] = ureg_DECL_constant(shader, i); 91 sampler[i] = ureg_DECL_sampler(shader, i); 92 } 93 texel = ureg_DECL_temporary(shader); 94 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0); 95 96 /* 97 * texel.xyz = tex(tc, sampler[i]) 98 * fragment = csc * texel 99 */ 100 for (i = 0; i < 3; ++i) 101 ureg_TEX(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), TGSI_TEXTURE_2D, tc, sampler[i]); 102 103 ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f)); 104 105 for (i = 0; i < 3; ++i) 106 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel)); 107 108 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f)); 109 110 ureg_release_temporary(shader, texel); 111 ureg_END(shader); 112 113 return ureg_create_shader_and_destroy(shader, c->pipe); 114} 115 116static void * 117create_frag_shader_palette(struct vl_compositor *c, bool include_cc) 118{ 119 struct ureg_program *shader; 120 struct ureg_src csc[3]; 121 struct ureg_src tc; 122 struct ureg_src sampler; 123 struct ureg_src palette; 124 struct ureg_dst texel; 125 struct ureg_dst fragment; 126 unsigned i; 127 128 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT); 129 if (!shader) 130 return false; 131 132 for (i = 0; i < 3; ++i) 133 csc[i] = ureg_DECL_constant(shader, i); 134 135 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, 1, TGSI_INTERPOLATE_LINEAR); 136 sampler = ureg_DECL_sampler(shader, 0); 137 palette = ureg_DECL_sampler(shader, 1); 138 139 texel = ureg_DECL_temporary(shader); 140 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0); 141 142 /* 143 * texel = tex(tc, sampler) 144 * fragment.xyz = tex(texel, palette) * csc 145 * fragment.a = texel.a 146 */ 147 ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler); 148 ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_src(texel)); 149 150 if (include_cc) { 151 ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette); 152 for (i = 0; i < 3; ++i) 153 ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel)); 154 } else { 155 ureg_TEX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XYZ), 156 TGSI_TEXTURE_1D, ureg_src(texel), palette); 157 } 158 159 ureg_release_temporary(shader, texel); 160 ureg_END(shader); 161 162 return ureg_create_shader_and_destroy(shader, c->pipe); 163} 164 165static void * 166create_frag_shader_rgba(struct vl_compositor *c) 167{ 168 struct ureg_program *shader; 169 struct ureg_src tc; 170 struct ureg_src sampler; 171 struct ureg_dst fragment; 172 173 shader = ureg_create(TGSI_PROCESSOR_FRAGMENT); 174 if (!shader) 175 return false; 176 177 tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, 1, TGSI_INTERPOLATE_LINEAR); 178 sampler = ureg_DECL_sampler(shader, 0); 179 fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0); 180 181 /* 182 * fragment = tex(tc, sampler) 183 */ 184 ureg_TEX(shader, fragment, TGSI_TEXTURE_2D, tc, sampler); 185 ureg_END(shader); 186 187 return ureg_create_shader_and_destroy(shader, c->pipe); 188} 189 190static bool 191init_shaders(struct vl_compositor *c) 192{ 193 assert(c); 194 195 c->vs = create_vert_shader(c); 196 if (!c->vs) { 197 debug_printf("Unable to create vertex shader.\n"); 198 return false; 199 } 200 201 c->fs_video_buffer = create_frag_shader_video_buffer(c); 202 if (!c->fs_video_buffer) { 203 debug_printf("Unable to create YCbCr-to-RGB fragment shader.\n"); 204 return false; 205 } 206 207 c->fs_palette.yuv = create_frag_shader_palette(c, true); 208 if (!c->fs_palette.yuv) { 209 debug_printf("Unable to create YUV-Palette-to-RGB fragment shader.\n"); 210 return false; 211 } 212 213 c->fs_palette.rgb = create_frag_shader_palette(c, false); 214 if (!c->fs_palette.rgb) { 215 debug_printf("Unable to create RGB-Palette-to-RGB fragment shader.\n"); 216 return false; 217 } 218 219 c->fs_rgba = create_frag_shader_rgba(c); 220 if (!c->fs_rgba) { 221 debug_printf("Unable to create RGB-to-RGB fragment shader.\n"); 222 return false; 223 } 224 225 return true; 226} 227 228static void cleanup_shaders(struct vl_compositor *c) 229{ 230 assert(c); 231 232 c->pipe->delete_vs_state(c->pipe, c->vs); 233 c->pipe->delete_fs_state(c->pipe, c->fs_video_buffer); 234 c->pipe->delete_fs_state(c->pipe, c->fs_palette.yuv); 235 c->pipe->delete_fs_state(c->pipe, c->fs_palette.rgb); 236 c->pipe->delete_fs_state(c->pipe, c->fs_rgba); 237} 238 239static bool 240init_pipe_state(struct vl_compositor *c) 241{ 242 struct pipe_rasterizer_state rast; 243 struct pipe_sampler_state sampler; 244 struct pipe_blend_state blend; 245 struct pipe_depth_stencil_alpha_state dsa; 246 unsigned i; 247 248 assert(c); 249 250 c->fb_state.nr_cbufs = 1; 251 c->fb_state.zsbuf = NULL; 252 253 c->viewport.scale[2] = 1; 254 c->viewport.scale[3] = 1; 255 c->viewport.translate[2] = 0; 256 c->viewport.translate[3] = 0; 257 258 memset(&sampler, 0, sizeof(sampler)); 259 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE; 260 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE; 261 sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE; 262 sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR; 263 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE; 264 sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR; 265 sampler.compare_mode = PIPE_TEX_COMPARE_NONE; 266 sampler.compare_func = PIPE_FUNC_ALWAYS; 267 sampler.normalized_coords = 1; 268 269 c->sampler_linear = c->pipe->create_sampler_state(c->pipe, &sampler); 270 271 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST; 272 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST; 273 c->sampler_nearest = c->pipe->create_sampler_state(c->pipe, &sampler); 274 275 memset(&blend, 0, sizeof blend); 276 blend.independent_blend_enable = 0; 277 blend.rt[0].blend_enable = 0; 278 blend.logicop_enable = 0; 279 blend.logicop_func = PIPE_LOGICOP_CLEAR; 280 blend.rt[0].colormask = PIPE_MASK_RGBA; 281 blend.dither = 0; 282 c->blend_clear = c->pipe->create_blend_state(c->pipe, &blend); 283 284 blend.rt[0].blend_enable = 1; 285 blend.rt[0].rgb_func = PIPE_BLEND_ADD; 286 blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA; 287 blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA; 288 blend.rt[0].alpha_func = PIPE_BLEND_ADD; 289 blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE; 290 blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE; 291 c->blend_add = c->pipe->create_blend_state(c->pipe, &blend); 292 293 memset(&rast, 0, sizeof rast); 294 rast.flatshade = 1; 295 rast.front_ccw = 1; 296 rast.cull_face = PIPE_FACE_NONE; 297 rast.fill_back = PIPE_POLYGON_MODE_FILL; 298 rast.fill_front = PIPE_POLYGON_MODE_FILL; 299 rast.scissor = 1; 300 rast.line_width = 1; 301 rast.point_size_per_vertex = 1; 302 rast.offset_units = 1; 303 rast.offset_scale = 1; 304 rast.gl_rasterization_rules = 1; 305 306 c->rast = c->pipe->create_rasterizer_state(c->pipe, &rast); 307 308 memset(&dsa, 0, sizeof dsa); 309 dsa.depth.enabled = 0; 310 dsa.depth.writemask = 0; 311 dsa.depth.func = PIPE_FUNC_ALWAYS; 312 for (i = 0; i < 2; ++i) { 313 dsa.stencil[i].enabled = 0; 314 dsa.stencil[i].func = PIPE_FUNC_ALWAYS; 315 dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP; 316 dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP; 317 dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP; 318 dsa.stencil[i].valuemask = 0; 319 dsa.stencil[i].writemask = 0; 320 } 321 dsa.alpha.enabled = 0; 322 dsa.alpha.func = PIPE_FUNC_ALWAYS; 323 dsa.alpha.ref_value = 0; 324 c->dsa = c->pipe->create_depth_stencil_alpha_state(c->pipe, &dsa); 325 c->pipe->bind_depth_stencil_alpha_state(c->pipe, c->dsa); 326 327 return true; 328} 329 330static void cleanup_pipe_state(struct vl_compositor *c) 331{ 332 assert(c); 333 334 /* Asserted in softpipe_delete_fs_state() for some reason */ 335 c->pipe->bind_vs_state(c->pipe, NULL); 336 c->pipe->bind_fs_state(c->pipe, NULL); 337 338 c->pipe->delete_depth_stencil_alpha_state(c->pipe, c->dsa); 339 c->pipe->delete_sampler_state(c->pipe, c->sampler_linear); 340 c->pipe->delete_sampler_state(c->pipe, c->sampler_nearest); 341 c->pipe->delete_blend_state(c->pipe, c->blend_clear); 342 c->pipe->delete_blend_state(c->pipe, c->blend_add); 343 c->pipe->delete_rasterizer_state(c->pipe, c->rast); 344} 345 346static bool 347create_vertex_buffer(struct vl_compositor *c) 348{ 349 assert(c); 350 351 pipe_resource_reference(&c->vertex_buf.buffer, NULL); 352 c->vertex_buf.buffer = pipe_buffer_create 353 ( 354 c->pipe->screen, 355 PIPE_BIND_VERTEX_BUFFER, 356 PIPE_USAGE_STREAM, 357 sizeof(struct vertex4f) * VL_COMPOSITOR_MAX_LAYERS * 4 358 ); 359 360 return c->vertex_buf.buffer != NULL; 361} 362 363static bool 364init_buffers(struct vl_compositor *c) 365{ 366 struct pipe_vertex_element vertex_elems[2]; 367 368 assert(c); 369 370 /* 371 * Create our vertex buffer and vertex buffer elements 372 */ 373 c->vertex_buf.stride = sizeof(struct vertex4f); 374 c->vertex_buf.buffer_offset = 0; 375 create_vertex_buffer(c); 376 377 vertex_elems[0].src_offset = 0; 378 vertex_elems[0].instance_divisor = 0; 379 vertex_elems[0].vertex_buffer_index = 0; 380 vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT; 381 vertex_elems[1].src_offset = sizeof(struct vertex2f); 382 vertex_elems[1].instance_divisor = 0; 383 vertex_elems[1].vertex_buffer_index = 0; 384 vertex_elems[1].src_format = PIPE_FORMAT_R32G32_FLOAT; 385 c->vertex_elems_state = c->pipe->create_vertex_elements_state(c->pipe, 2, vertex_elems); 386 387 /* 388 * Create our fragment shader's constant buffer 389 * Const buffer contains the color conversion matrix and bias vectors 390 */ 391 /* XXX: Create with IMMUTABLE/STATIC... although it does change every once in a long while... */ 392 c->csc_matrix = pipe_buffer_create 393 ( 394 c->pipe->screen, 395 PIPE_BIND_CONSTANT_BUFFER, 396 PIPE_USAGE_STATIC, 397 sizeof(csc_matrix) 398 ); 399 400 return true; 401} 402 403static void 404cleanup_buffers(struct vl_compositor *c) 405{ 406 assert(c); 407 408 c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems_state); 409 pipe_resource_reference(&c->vertex_buf.buffer, NULL); 410 pipe_resource_reference(&c->csc_matrix, NULL); 411} 412 413static INLINE struct pipe_video_rect 414default_rect(struct vl_compositor_layer *layer) 415{ 416 struct pipe_resource *res = layer->sampler_views[0]->texture; 417 struct pipe_video_rect rect = { 0, 0, res->width0, res->height0 }; 418 return rect; 419} 420 421static INLINE struct vertex2f 422calc_topleft(struct vertex2f size, struct pipe_video_rect rect) 423{ 424 struct vertex2f res = { rect.x / size.x, rect.y / size.y }; 425 return res; 426} 427 428static INLINE struct vertex2f 429calc_bottomright(struct vertex2f size, struct pipe_video_rect rect) 430{ 431 struct vertex2f res = { (rect.x + rect.w) / size.x, (rect.y + rect.h) / size.y }; 432 return res; 433} 434 435static INLINE void 436calc_src_and_dst(struct vl_compositor_layer *layer, unsigned width, unsigned height, 437 struct pipe_video_rect src, struct pipe_video_rect dst) 438{ 439 struct vertex2f size = { width, height }; 440 441 layer->src.tl = calc_topleft(size, src); 442 layer->src.br = calc_bottomright(size, src); 443 layer->dst.tl = calc_topleft(size, dst); 444 layer->dst.br = calc_bottomright(size, dst); 445} 446 447static void 448gen_rect_verts(struct vertex4f *vb, struct vl_compositor_layer *layer) 449{ 450 assert(vb && layer); 451 452 vb[0].x = layer->dst.tl.x; 453 vb[0].y = layer->dst.tl.y; 454 vb[0].z = layer->src.tl.x; 455 vb[0].w = layer->src.tl.y; 456 457 vb[1].x = layer->dst.br.x; 458 vb[1].y = layer->dst.tl.y; 459 vb[1].z = layer->src.br.x; 460 vb[1].w = layer->src.tl.y; 461 462 vb[2].x = layer->dst.br.x; 463 vb[2].y = layer->dst.br.y; 464 vb[2].z = layer->src.br.x; 465 vb[2].w = layer->src.br.y; 466 467 vb[3].x = layer->dst.tl.x; 468 vb[3].y = layer->dst.br.y; 469 vb[3].z = layer->src.tl.x; 470 vb[3].w = layer->src.br.y; 471} 472 473static void 474gen_vertex_data(struct vl_compositor *c) 475{ 476 struct vertex4f *vb; 477 struct pipe_transfer *buf_transfer; 478 unsigned i; 479 480 assert(c); 481 482 vb = pipe_buffer_map(c->pipe, c->vertex_buf.buffer, 483 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD | PIPE_TRANSFER_DONTBLOCK, 484 &buf_transfer); 485 486 if (!vb) { 487 // If buffer is still locked from last draw create a new one 488 create_vertex_buffer(c); 489 vb = pipe_buffer_map(c->pipe, c->vertex_buf.buffer, 490 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD, 491 &buf_transfer); 492 } 493 494 for (i = 0; i < VL_COMPOSITOR_MAX_LAYERS; i++) { 495 if (c->used_layers & (1 << i)) { 496 struct vl_compositor_layer *layer = &c->layers[i]; 497 gen_rect_verts(vb, layer); 498 vb += 4; 499 500 if (layer->clearing && 501 c->dirty_tl.x >= layer->dst.tl.x && 502 c->dirty_tl.y >= layer->dst.tl.y && 503 c->dirty_br.x <= layer->dst.br.x && 504 c->dirty_br.y <= layer->dst.br.y) { 505 506 // We clear the dirty area anyway, no need for clear_render_target 507 c->dirty_tl.x = c->dirty_tl.y = 1.0f; 508 c->dirty_br.x = c->dirty_br.y = 0.0f; 509 } 510 } 511 } 512 513 pipe_buffer_unmap(c->pipe, buf_transfer); 514} 515 516static void 517draw_layers(struct vl_compositor *c) 518{ 519 unsigned vb_index, i; 520 521 assert(c); 522 523 for (i = 0, vb_index = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) { 524 if (c->used_layers & (1 << i)) { 525 struct vl_compositor_layer *layer = &c->layers[i]; 526 struct pipe_sampler_view **samplers = &layer->sampler_views[0]; 527 unsigned num_sampler_views = !samplers[1] ? 1 : !samplers[2] ? 2 : 3; 528 529 c->pipe->bind_blend_state(c->pipe, layer->blend); 530 c->pipe->bind_fs_state(c->pipe, layer->fs); 531 c->pipe->bind_fragment_sampler_states(c->pipe, num_sampler_views, layer->samplers); 532 c->pipe->set_fragment_sampler_views(c->pipe, num_sampler_views, samplers); 533 util_draw_arrays(c->pipe, PIPE_PRIM_QUADS, vb_index * 4, 4); 534 vb_index++; 535 536 // Remember the currently drawn area as dirty for the next draw command 537 c->dirty_tl.x = MIN2(layer->dst.tl.x, c->dirty_tl.x); 538 c->dirty_tl.y = MIN2(layer->dst.tl.y, c->dirty_tl.y); 539 c->dirty_br.x = MAX2(layer->dst.br.x, c->dirty_br.x); 540 c->dirty_br.y = MAX2(layer->dst.br.y, c->dirty_br.y); 541 } 542 } 543} 544 545void 546vl_compositor_reset_dirty_area(struct vl_compositor *c) 547{ 548 assert(c); 549 550 c->dirty_tl.x = c->dirty_tl.y = 0.0f; 551 c->dirty_br.x = c->dirty_br.y = 1.0f; 552} 553 554void 555vl_compositor_set_clear_color(struct vl_compositor *c, float color[4]) 556{ 557 unsigned i; 558 559 assert(c); 560 561 for (i = 0; i < 4; ++i) 562 c->clear_color[i] = color[i]; 563} 564 565void 566vl_compositor_clear_layers(struct vl_compositor *c) 567{ 568 unsigned i, j; 569 570 assert(c); 571 572 c->used_layers = 0; 573 for ( i = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) { 574 c->layers[i].clearing = i ? false : true; 575 c->layers[i].blend = i ? c->blend_add : c->blend_clear; 576 c->layers[i].fs = NULL; 577 for ( j = 0; j < 3; j++) 578 pipe_sampler_view_reference(&c->layers[i].sampler_views[j], NULL); 579 } 580} 581 582void 583vl_compositor_cleanup(struct vl_compositor *c) 584{ 585 assert(c); 586 587 vl_compositor_clear_layers(c); 588 589 cleanup_buffers(c); 590 cleanup_shaders(c); 591 cleanup_pipe_state(c); 592} 593 594void 595vl_compositor_set_csc_matrix(struct vl_compositor *c, const float matrix[16]) 596{ 597 struct pipe_transfer *buf_transfer; 598 599 assert(c); 600 601 memcpy 602 ( 603 pipe_buffer_map(c->pipe, c->csc_matrix, 604 PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD, 605 &buf_transfer), 606 matrix, 607 sizeof(csc_matrix) 608 ); 609 610 pipe_buffer_unmap(c->pipe, buf_transfer); 611} 612 613void 614vl_compositor_set_layer_blend(struct vl_compositor *c, 615 unsigned layer, void *blend, 616 bool is_clearing) 617{ 618 assert(c && blend); 619 620 assert(layer < VL_COMPOSITOR_MAX_LAYERS); 621 622 c->layers[layer].clearing = is_clearing; 623 c->layers[layer].blend = blend; 624} 625 626void 627vl_compositor_set_buffer_layer(struct vl_compositor *c, 628 unsigned layer, 629 struct pipe_video_buffer *buffer, 630 struct pipe_video_rect *src_rect, 631 struct pipe_video_rect *dst_rect) 632{ 633 struct pipe_sampler_view **sampler_views; 634 unsigned i; 635 636 assert(c && buffer); 637 638 assert(layer < VL_COMPOSITOR_MAX_LAYERS); 639 640 c->used_layers |= 1 << layer; 641 c->layers[layer].fs = c->fs_video_buffer; 642 643 sampler_views = buffer->get_sampler_view_components(buffer); 644 for (i = 0; i < 3; ++i) { 645 c->layers[layer].samplers[i] = c->sampler_linear; 646 pipe_sampler_view_reference(&c->layers[layer].sampler_views[i], sampler_views[i]); 647 } 648 649 calc_src_and_dst(&c->layers[layer], buffer->width, buffer->height, 650 src_rect ? *src_rect : default_rect(&c->layers[layer]), 651 dst_rect ? *dst_rect : default_rect(&c->layers[layer])); 652} 653 654void 655vl_compositor_set_palette_layer(struct vl_compositor *c, 656 unsigned layer, 657 struct pipe_sampler_view *indexes, 658 struct pipe_sampler_view *palette, 659 struct pipe_video_rect *src_rect, 660 struct pipe_video_rect *dst_rect, 661 bool include_color_conversion) 662{ 663 assert(c && indexes && palette); 664 665 assert(layer < VL_COMPOSITOR_MAX_LAYERS); 666 667 c->used_layers |= 1 << layer; 668 669 c->layers[layer].fs = include_color_conversion ? 670 c->fs_palette.yuv : c->fs_palette.rgb; 671 672 c->layers[layer].samplers[0] = c->sampler_linear; 673 c->layers[layer].samplers[1] = c->sampler_nearest; 674 c->layers[layer].samplers[2] = NULL; 675 pipe_sampler_view_reference(&c->layers[layer].sampler_views[0], indexes); 676 pipe_sampler_view_reference(&c->layers[layer].sampler_views[1], palette); 677 pipe_sampler_view_reference(&c->layers[layer].sampler_views[2], NULL); 678 calc_src_and_dst(&c->layers[layer], indexes->texture->width0, indexes->texture->height0, 679 src_rect ? *src_rect : default_rect(&c->layers[layer]), 680 dst_rect ? *dst_rect : default_rect(&c->layers[layer])); 681} 682 683void 684vl_compositor_set_rgba_layer(struct vl_compositor *c, 685 unsigned layer, 686 struct pipe_sampler_view *rgba, 687 struct pipe_video_rect *src_rect, 688 struct pipe_video_rect *dst_rect) 689{ 690 assert(c && rgba); 691 692 assert(layer < VL_COMPOSITOR_MAX_LAYERS); 693 694 c->used_layers |= 1 << layer; 695 c->layers[layer].fs = c->fs_rgba; 696 c->layers[layer].samplers[0] = c->sampler_linear; 697 c->layers[layer].samplers[1] = NULL; 698 c->layers[layer].samplers[2] = NULL; 699 pipe_sampler_view_reference(&c->layers[layer].sampler_views[0], rgba); 700 pipe_sampler_view_reference(&c->layers[layer].sampler_views[1], NULL); 701 pipe_sampler_view_reference(&c->layers[layer].sampler_views[2], NULL); 702 calc_src_and_dst(&c->layers[layer], rgba->texture->width0, rgba->texture->height0, 703 src_rect ? *src_rect : default_rect(&c->layers[layer]), 704 dst_rect ? *dst_rect : default_rect(&c->layers[layer])); 705} 706 707void 708vl_compositor_render(struct vl_compositor *c, 709 struct pipe_surface *dst_surface, 710 struct pipe_video_rect *dst_area, 711 struct pipe_video_rect *dst_clip, 712 bool clear_dirty_area) 713{ 714 struct pipe_scissor_state scissor; 715 716 assert(c); 717 assert(dst_surface); 718 719 c->fb_state.width = dst_surface->width; 720 c->fb_state.height = dst_surface->height; 721 c->fb_state.cbufs[0] = dst_surface; 722 723 if (dst_area) { 724 c->viewport.scale[0] = dst_area->w; 725 c->viewport.scale[1] = dst_area->h; 726 c->viewport.translate[0] = dst_area->x; 727 c->viewport.translate[1] = dst_area->y; 728 } else { 729 c->viewport.scale[0] = dst_surface->width; 730 c->viewport.scale[1] = dst_surface->height; 731 c->viewport.translate[0] = 0; 732 c->viewport.translate[1] = 0; 733 } 734 735 if (dst_clip) { 736 scissor.minx = dst_clip->x; 737 scissor.miny = dst_clip->y; 738 scissor.maxx = dst_clip->x + dst_clip->w; 739 scissor.maxy = dst_clip->y + dst_clip->h; 740 } else { 741 scissor.minx = 0; 742 scissor.miny = 0; 743 scissor.maxx = dst_surface->width; 744 scissor.maxy = dst_surface->height; 745 } 746 747 gen_vertex_data(c); 748 749 if (clear_dirty_area && (c->dirty_tl.x < c->dirty_br.x || 750 c->dirty_tl.y < c->dirty_br.y)) { 751 util_clear_render_target(c->pipe, dst_surface, c->clear_color, 752 0, 0, dst_surface->width, dst_surface->height); 753 c->dirty_tl.x = c->dirty_tl.y = 1.0f; 754 c->dirty_br.x = c->dirty_br.y = 0.0f; 755 } 756 757 c->pipe->set_scissor_state(c->pipe, &scissor); 758 c->pipe->set_framebuffer_state(c->pipe, &c->fb_state); 759 c->pipe->set_viewport_state(c->pipe, &c->viewport); 760 c->pipe->bind_vs_state(c->pipe, c->vs); 761 c->pipe->set_vertex_buffers(c->pipe, 1, &c->vertex_buf); 762 c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state); 763 c->pipe->set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, c->csc_matrix); 764 c->pipe->bind_rasterizer_state(c->pipe, c->rast); 765 766 draw_layers(c); 767} 768 769bool 770vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe) 771{ 772 csc_matrix csc_matrix; 773 774 c->pipe = pipe; 775 776 if (!init_pipe_state(c)) 777 return false; 778 779 if (!init_shaders(c)) { 780 cleanup_pipe_state(c); 781 return false; 782 } 783 784 if (!init_buffers(c)) { 785 cleanup_shaders(c); 786 cleanup_pipe_state(c); 787 return false; 788 } 789 790 vl_compositor_clear_layers(c); 791 792 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, csc_matrix); 793 vl_compositor_set_csc_matrix(c, csc_matrix); 794 795 c->clear_color[0] = c->clear_color[1] = 0.0f; 796 c->clear_color[2] = c->clear_color[3] = 0.0f; 797 vl_compositor_reset_dirty_area(c); 798 799 return true; 800} 801