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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include <assert.h>
  29
  30 #include "pipe/p_compiler.h"
  31 #include "pipe/p_context.h"
  32
  33 #include "util/u_memory.h"
  34 #include "util/u_draw.h"
  35 #include "util/u_surface.h"
  36
  37 #include "tgsi/tgsi_ureg.h"
  38
  39 #include "vl_csc.h"
  40 #include "vl_types.h"
  41 #include "vl_compositor.h"
  42
  43 typedef float csc_matrix[16];
  44
  45 static void *
  46 create_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
  73 static void *
  74 create_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
 116 static void *
 117 create_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
 165 static void *
 166 create_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
 190 static bool
 191 init_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
 228 static 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
 239 static bool
 240 init_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
 330 static 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
 346 static bool
 347 create_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
 363 static bool
 364 init_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
 403 static void
 404 cleanup_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
 413 static INLINE struct pipe_video_rect
 414 default_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
 421 static INLINE struct vertex2f
 422 calc_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
 428 static INLINE struct vertex2f
 429 calc_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
 435 static INLINE void
 436 calc_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
 447 static void
 448 gen_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
 473 static void
 474 gen_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
 516 static void
 517 draw_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
 545 void
 546 vl_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
 554 void
 555 vl_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
 565 void
 566 vl_compositor_get_clear_color(struct vl_compositor *c, float color[4])
 567 {
 568    unsigned i;
 569
 570    assert(c);
 571    assert(color);
 572
 573    for (i = 0; i < 4; ++i)
 574       color[i] = c->clear_color[i];
 575 }
 576
 577 void
 578 vl_compositor_clear_layers(struct vl_compositor *c)
 579 {
 580    unsigned i, j;
 581
 582    assert(c);
 583
 584    c->used_layers = 0;
 585    for ( i = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
 586       c->layers[i].clearing = i ? false : true;
 587       c->layers[i].blend = i ? c->blend_add : c->blend_clear;
 588       c->layers[i].fs = NULL;
 589       for ( j = 0; j < 3; j++)
 590          pipe_sampler_view_reference(&c->layers[i].sampler_views[j], NULL);
 591    }
 592 }
 593
 594 void
 595 vl_compositor_cleanup(struct vl_compositor *c)
 596 {
 597    assert(c);
 598
 599    vl_compositor_clear_layers(c);
 600
 601    cleanup_buffers(c);
 602    cleanup_shaders(c);
 603    cleanup_pipe_state(c);
 604 }
 605
 606 void
 607 vl_compositor_set_csc_matrix(struct vl_compositor *c, const float matrix[16])
 608 {
 609    struct pipe_transfer *buf_transfer;
 610
 611    assert(c);
 612
 613    memcpy
 614    (
 615       pipe_buffer_map(c->pipe, c->csc_matrix,
 616                       PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD,
 617                       &buf_transfer),
 618       matrix,
 619       sizeof(csc_matrix)
 620    );
 621
 622    pipe_buffer_unmap(c->pipe, buf_transfer);
 623 }
 624
 625 void
 626 vl_compositor_set_layer_blend(struct vl_compositor *c,
 627                               unsigned layer, void *blend,
 628                               bool is_clearing)
 629 {
 630    assert(c && blend);
 631
 632    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 633
 634    c->layers[layer].clearing = is_clearing;
 635    c->layers[layer].blend = blend;
 636 }
 637
 638 void
 639 vl_compositor_set_buffer_layer(struct vl_compositor *c,
 640                                unsigned layer,
 641                                struct pipe_video_buffer *buffer,
 642                                struct pipe_video_rect *src_rect,
 643                                struct pipe_video_rect *dst_rect)
 644 {
 645    struct pipe_sampler_view **sampler_views;
 646    unsigned i;
 647
 648    assert(c && buffer);
 649
 650    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 651
 652    c->used_layers |= 1 << layer;
 653    c->layers[layer].fs = c->fs_video_buffer;
 654
 655    sampler_views = buffer->get_sampler_view_components(buffer);
 656    for (i = 0; i < 3; ++i) {
 657       c->layers[layer].samplers[i] = c->sampler_linear;
 658       pipe_sampler_view_reference(&c->layers[layer].sampler_views[i], sampler_views[i]);
 659    }
 660
 661    calc_src_and_dst(&c->layers[layer], buffer->width, buffer->height,
 662                     src_rect ? *src_rect : default_rect(&c->layers[layer]),
 663                     dst_rect ? *dst_rect : default_rect(&c->layers[layer]));
 664 }
 665
 666 void
 667 vl_compositor_set_palette_layer(struct vl_compositor *c,
 668                                 unsigned layer,
 669                                 struct pipe_sampler_view *indexes,
 670                                 struct pipe_sampler_view *palette,
 671                                 struct pipe_video_rect *src_rect,
 672                                 struct pipe_video_rect *dst_rect,
 673                                 bool include_color_conversion)
 674 {
 675    assert(c && indexes && palette);
 676
 677    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 678
 679    c->used_layers |= 1 << layer;
 680
 681    c->layers[layer].fs = include_color_conversion ?
 682       c->fs_palette.yuv : c->fs_palette.rgb;
 683
 684    c->layers[layer].samplers[0] = c->sampler_linear;
 685    c->layers[layer].samplers[1] = c->sampler_nearest;
 686    c->layers[layer].samplers[2] = NULL;
 687    pipe_sampler_view_reference(&c->layers[layer].sampler_views[0], indexes);
 688    pipe_sampler_view_reference(&c->layers[layer].sampler_views[1], palette);
 689    pipe_sampler_view_reference(&c->layers[layer].sampler_views[2], NULL);
 690    calc_src_and_dst(&c->layers[layer], indexes->texture->width0, indexes->texture->height0,
 691                     src_rect ? *src_rect : default_rect(&c->layers[layer]),
 692                     dst_rect ? *dst_rect : default_rect(&c->layers[layer]));
 693 }
 694
 695 void
 696 vl_compositor_set_rgba_layer(struct vl_compositor *c,
 697                              unsigned layer,
 698                              struct pipe_sampler_view *rgba,
 699                              struct pipe_video_rect *src_rect,
 700                              struct pipe_video_rect *dst_rect)
 701 {
 702    assert(c && rgba);
 703
 704    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 705
 706    c->used_layers |= 1 << layer;
 707    c->layers[layer].fs = c->fs_rgba;
 708    c->layers[layer].samplers[0] = c->sampler_linear;
 709    c->layers[layer].samplers[1] = NULL;
 710    c->layers[layer].samplers[2] = NULL;
 711    pipe_sampler_view_reference(&c->layers[layer].sampler_views[0], rgba);
 712    pipe_sampler_view_reference(&c->layers[layer].sampler_views[1], NULL);
 713    pipe_sampler_view_reference(&c->layers[layer].sampler_views[2], NULL);
 714    calc_src_and_dst(&c->layers[layer], rgba->texture->width0, rgba->texture->height0,
 715                     src_rect ? *src_rect : default_rect(&c->layers[layer]),
 716                     dst_rect ? *dst_rect : default_rect(&c->layers[layer]));
 717 }
 718
 719 void
 720 vl_compositor_render(struct vl_compositor   *c,
 721                      struct pipe_surface    *dst_surface,
 722                      struct pipe_video_rect *dst_area,
 723                      struct pipe_video_rect *dst_clip,
 724                      bool clear_dirty_area)
 725 {
 726    struct pipe_scissor_state scissor;
 727
 728    assert(c);
 729    assert(dst_surface);
 730
 731    c->fb_state.width = dst_surface->width;
 732    c->fb_state.height = dst_surface->height;
 733    c->fb_state.cbufs[0] = dst_surface;
 734
 735    if (dst_area) {
 736       c->viewport.scale[0] = dst_area->w;
 737       c->viewport.scale[1] = dst_area->h;
 738       c->viewport.translate[0] = dst_area->x;
 739       c->viewport.translate[1] = dst_area->y;
 740    } else {
 741       c->viewport.scale[0] = dst_surface->width;
 742       c->viewport.scale[1] = dst_surface->height;
 743       c->viewport.translate[0] = 0;
 744       c->viewport.translate[1] = 0;
 745    }
 746
 747    if (dst_clip) {
 748       scissor.minx = dst_clip->x;
 749       scissor.miny = dst_clip->y;
 750       scissor.maxx = dst_clip->x + dst_clip->w;
 751       scissor.maxy = dst_clip->y + dst_clip->h;
 752    } else {
 753       scissor.minx = 0;
 754       scissor.miny = 0;
 755       scissor.maxx = dst_surface->width;
 756       scissor.maxy = dst_surface->height;
 757    }
 758
 759    gen_vertex_data(c);
 760
 761    if (clear_dirty_area && (c->dirty_tl.x < c->dirty_br.x ||
 762                             c->dirty_tl.y < c->dirty_br.y)) {
 763       util_clear_render_target(c->pipe, dst_surface, c->clear_color,
 764                                0, 0, dst_surface->width, dst_surface->height);
 765       c->dirty_tl.x = c->dirty_tl.y = 1.0f;
 766       c->dirty_br.x = c->dirty_br.y = 0.0f;
 767    }
 768
 769    c->pipe->set_scissor_state(c->pipe, &scissor);
 770    c->pipe->set_framebuffer_state(c->pipe, &c->fb_state);
 771    c->pipe->set_viewport_state(c->pipe, &c->viewport);
 772    c->pipe->bind_vs_state(c->pipe, c->vs);
 773    c->pipe->set_vertex_buffers(c->pipe, 1, &c->vertex_buf);
 774    c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state);
 775    c->pipe->set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, c->csc_matrix);
 776    c->pipe->bind_rasterizer_state(c->pipe, c->rast);
 777
 778    draw_layers(c);
 779 }
 780
 781 bool
 782 vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe)
 783 {
 784    csc_matrix csc_matrix;
 785
 786    c->pipe = pipe;
 787
 788    if (!init_pipe_state(c))
 789       return false;
 790
 791    if (!init_shaders(c)) {
 792       cleanup_pipe_state(c);
 793       return false;
 794    }
 795
 796    if (!init_buffers(c)) {
 797       cleanup_shaders(c);
 798       cleanup_pipe_state(c);
 799       return false;
 800    }
 801
 802    vl_compositor_clear_layers(c);
 803
 804    vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, csc_matrix);
 805    vl_compositor_set_csc_matrix(c, csc_matrix);
 806
 807    c->clear_color[0] = c->clear_color[1] = 0.0f;
 808    c->clear_color[2] = c->clear_color[3] = 0.0f;
 809    vl_compositor_reset_dirty_area(c);
 810
 811    return true;
 812 }