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 "util/u_sampler.h"
  29
  30 #include "vl_compositor_gfx.h"
  31 #include "vl_compositor_cs.h"
  32
  33 static bool
  34 init_shaders(struct vl_compositor *c)
  35 {
  36    assert(c);
  37
  38    if (c->pipe_cs_composit_supported) {
  39       if (!vl_compositor_cs_init_shaders(c))
  40          return false;
  41
  42    } else if (c->pipe_gfx_supported) {
  43       c->fs_video_buffer = create_frag_shader_video_buffer(c);
  44       if (!c->fs_video_buffer) {
  45          debug_printf("Unable to create YCbCr-to-RGB fragment shader.\n");
  46          return false;
  47       }
  48
  49       c->fs_weave_rgb = create_frag_shader_weave_rgb(c);
  50       if (!c->fs_weave_rgb) {
  51          debug_printf("Unable to create YCbCr-to-RGB weave fragment shader.\n");
  52          return false;
  53       }
  54
  55       c->fs_yuv.weave.y = create_frag_shader_deint_yuv(c, true, true);
  56       c->fs_yuv.weave.uv = create_frag_shader_deint_yuv(c, false, true);
  57       c->fs_yuv.bob.y = create_frag_shader_deint_yuv(c, true, false);
  58       c->fs_yuv.bob.uv = create_frag_shader_deint_yuv(c, false, false);
  59       if (!c->fs_yuv.weave.y || !c->fs_yuv.weave.uv ||
  60           !c->fs_yuv.bob.y || !c->fs_yuv.bob.uv) {
  61          debug_printf("Unable to create YCbCr i-to-YCbCr p deint fragment shader.\n");
  62          return false;
  63       }
  64    }
  65
  66    if (c->pipe_gfx_supported) {
  67       c->vs = create_vert_shader(c);
  68       if (!c->vs) {
  69          debug_printf("Unable to create vertex shader.\n");
  70          return false;
  71       }
  72
  73       c->fs_palette.yuv = create_frag_shader_palette(c, true);
  74       if (!c->fs_palette.yuv) {
  75          debug_printf("Unable to create YUV-Palette-to-RGB fragment shader.\n");
  76          return false;
  77       }
  78
  79       c->fs_palette.rgb = create_frag_shader_palette(c, false);
  80       if (!c->fs_palette.rgb) {
  81          debug_printf("Unable to create RGB-Palette-to-RGB fragment shader.\n");
  82          return false;
  83       }
  84
  85       c->fs_rgb_yuv.y = create_frag_shader_rgb_yuv(c, true);
  86       c->fs_rgb_yuv.uv = create_frag_shader_rgb_yuv(c, false);
  87       if (!c->fs_rgb_yuv.y || !c->fs_rgb_yuv.uv) {
  88          debug_printf("Unable to create RGB-to-YUV fragment shader.\n");
  89          return false;
  90       }
  91
  92       c->fs_rgba = create_frag_shader_rgba(c);
  93       if (!c->fs_rgba) {
  94          debug_printf("Unable to create RGB-to-RGB fragment shader.\n");
  95          return false;
  96       }
  97    }
  98
  99    return true;
 100 }
 101
 102 static void cleanup_shaders(struct vl_compositor *c)
 103 {
 104    assert(c);
 105
 106    if (c->pipe_cs_composit_supported) {
 107       vl_compositor_cs_cleanup_shaders(c);
 108    } else if (c->pipe_gfx_supported) {
 109       c->pipe->delete_fs_state(c->pipe, c->fs_video_buffer);
 110       c->pipe->delete_fs_state(c->pipe, c->fs_weave_rgb);
 111       c->pipe->delete_fs_state(c->pipe, c->fs_yuv.weave.y);
 112       c->pipe->delete_fs_state(c->pipe, c->fs_yuv.weave.uv);
 113       c->pipe->delete_fs_state(c->pipe, c->fs_yuv.bob.y);
 114       c->pipe->delete_fs_state(c->pipe, c->fs_yuv.bob.uv);
 115    }
 116
 117    if (c->pipe_gfx_supported) {
 118       c->pipe->delete_vs_state(c->pipe, c->vs);
 119       c->pipe->delete_fs_state(c->pipe, c->fs_palette.yuv);
 120       c->pipe->delete_fs_state(c->pipe, c->fs_palette.rgb);
 121       c->pipe->delete_fs_state(c->pipe, c->fs_rgb_yuv.y);
 122       c->pipe->delete_fs_state(c->pipe, c->fs_rgb_yuv.uv);
 123       c->pipe->delete_fs_state(c->pipe, c->fs_rgba);
 124    }
 125 }
 126
 127 static bool
 128 init_pipe_state(struct vl_compositor *c)
 129 {
 130    struct pipe_rasterizer_state rast;
 131    struct pipe_sampler_state sampler;
 132    struct pipe_blend_state blend;
 133    struct pipe_depth_stencil_alpha_state dsa;
 134    unsigned i;
 135
 136    assert(c);
 137
 138    c->fb_state.nr_cbufs = 1;
 139    c->fb_state.zsbuf = NULL;
 140
 141    memset(&sampler, 0, sizeof(sampler));
 142    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 143    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 144    sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
 145    sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
 146    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 147    sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
 148    sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
 149    sampler.compare_func = PIPE_FUNC_ALWAYS;
 150    sampler.normalized_coords = 1;
 151
 152    c->sampler_linear = c->pipe->create_sampler_state(c->pipe, &sampler);
 153
 154    sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 155    sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 156    c->sampler_nearest = c->pipe->create_sampler_state(c->pipe, &sampler);
 157
 158    if (c->pipe_gfx_supported) {
 159            memset(&blend, 0, sizeof blend);
 160            blend.independent_blend_enable = 0;
 161            blend.rt[0].blend_enable = 0;
 162            blend.logicop_enable = 0;
 163            blend.logicop_func = PIPE_LOGICOP_CLEAR;
 164            blend.rt[0].colormask = PIPE_MASK_RGBA;
 165            blend.dither = 0;
 166            c->blend_clear = c->pipe->create_blend_state(c->pipe, &blend);
 167
 168            blend.rt[0].blend_enable = 1;
 169            blend.rt[0].rgb_func = PIPE_BLEND_ADD;
 170            blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
 171            blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
 172            blend.rt[0].alpha_func = PIPE_BLEND_ADD;
 173            blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
 174            blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
 175            c->blend_add = c->pipe->create_blend_state(c->pipe, &blend);
 176
 177            memset(&rast, 0, sizeof rast);
 178            rast.flatshade = 0;
 179            rast.front_ccw = 1;
 180            rast.cull_face = PIPE_FACE_NONE;
 181            rast.fill_back = PIPE_POLYGON_MODE_FILL;
 182            rast.fill_front = PIPE_POLYGON_MODE_FILL;
 183            rast.scissor = 1;
 184            rast.line_width = 1;
 185            rast.point_size_per_vertex = 1;
 186            rast.offset_units = 1;
 187            rast.offset_scale = 1;
 188            rast.half_pixel_center = 1;
 189            rast.bottom_edge_rule = 1;
 190            rast.depth_clip_near = 1;
 191            rast.depth_clip_far = 1;
 192
 193            c->rast = c->pipe->create_rasterizer_state(c->pipe, &rast);
 194
 195            memset(&dsa, 0, sizeof dsa);
 196            dsa.depth.enabled = 0;
 197            dsa.depth.writemask = 0;
 198            dsa.depth.func = PIPE_FUNC_ALWAYS;
 199            for (i = 0; i < 2; ++i) {
 200                    dsa.stencil[i].enabled = 0;
 201                    dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
 202                    dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
 203                    dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
 204                    dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
 205                    dsa.stencil[i].valuemask = 0;
 206                    dsa.stencil[i].writemask = 0;
 207            }
 208            dsa.alpha.enabled = 0;
 209            dsa.alpha.func = PIPE_FUNC_ALWAYS;
 210            dsa.alpha.ref_value = 0;
 211            c->dsa = c->pipe->create_depth_stencil_alpha_state(c->pipe, &dsa);
 212            c->pipe->bind_depth_stencil_alpha_state(c->pipe, c->dsa);
 213    }
 214
 215    return true;
 216 }
 217
 218 static void cleanup_pipe_state(struct vl_compositor *c)
 219 {
 220    assert(c);
 221
 222    if (c->pipe_gfx_supported) {
 223            /* Asserted in softpipe_delete_fs_state() for some reason */
 224            c->pipe->bind_vs_state(c->pipe, NULL);
 225            c->pipe->bind_fs_state(c->pipe, NULL);
 226
 227            c->pipe->delete_depth_stencil_alpha_state(c->pipe, c->dsa);
 228            c->pipe->delete_blend_state(c->pipe, c->blend_clear);
 229            c->pipe->delete_blend_state(c->pipe, c->blend_add);
 230            c->pipe->delete_rasterizer_state(c->pipe, c->rast);
 231    }
 232    c->pipe->delete_sampler_state(c->pipe, c->sampler_linear);
 233    c->pipe->delete_sampler_state(c->pipe, c->sampler_nearest);
 234 }
 235
 236 static bool
 237 init_buffers(struct vl_compositor *c)
 238 {
 239    struct pipe_vertex_element vertex_elems[3];
 240
 241    assert(c);
 242
 243    /*
 244     * Create our vertex buffer and vertex buffer elements
 245     */
 246    c->vertex_buf.stride = sizeof(struct vertex2f) + sizeof(struct vertex4f) * 2;
 247    c->vertex_buf.buffer_offset = 0;
 248    c->vertex_buf.buffer.resource = NULL;
 249    c->vertex_buf.is_user_buffer = false;
 250
 251    if (c->pipe_gfx_supported) {
 252            vertex_elems[0].src_offset = 0;
 253            vertex_elems[0].instance_divisor = 0;
 254            vertex_elems[0].vertex_buffer_index = 0;
 255            vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
 256            vertex_elems[1].src_offset = sizeof(struct vertex2f);
 257            vertex_elems[1].instance_divisor = 0;
 258            vertex_elems[1].vertex_buffer_index = 0;
 259            vertex_elems[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 260            vertex_elems[2].src_offset = sizeof(struct vertex2f) + sizeof(struct vertex4f);
 261            vertex_elems[2].instance_divisor = 0;
 262            vertex_elems[2].vertex_buffer_index = 0;
 263            vertex_elems[2].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 264            c->vertex_elems_state = c->pipe->create_vertex_elements_state(c->pipe, 3, vertex_elems);
 265    }
 266
 267    return true;
 268 }
 269
 270 static void
 271 cleanup_buffers(struct vl_compositor *c)
 272 {
 273    assert(c);
 274
 275    if (c->pipe_gfx_supported) {
 276            c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems_state);
 277    }
 278    pipe_resource_reference(&c->vertex_buf.buffer.resource, NULL);
 279 }
 280
 281 static inline struct u_rect
 282 default_rect(struct vl_compositor_layer *layer)
 283 {
 284    struct pipe_resource *res = layer->sampler_views[0]->texture;
 285    struct u_rect rect = { 0, res->width0, 0, res->height0 * res->array_size };
 286    return rect;
 287 }
 288
 289 static inline struct vertex2f
 290 calc_topleft(struct vertex2f size, struct u_rect rect)
 291 {
 292    struct vertex2f res = { rect.x0 / size.x, rect.y0 / size.y };
 293    return res;
 294 }
 295
 296 static inline struct vertex2f
 297 calc_bottomright(struct vertex2f size, struct u_rect rect)
 298 {
 299    struct vertex2f res = { rect.x1 / size.x, rect.y1 / size.y };
 300    return res;
 301 }
 302
 303 static inline void
 304 calc_src_and_dst(struct vl_compositor_layer *layer, unsigned width, unsigned height,
 305                  struct u_rect src, struct u_rect dst)
 306 {
 307    struct vertex2f size =  { width, height };
 308
 309    layer->src.tl = calc_topleft(size, src);
 310    layer->src.br = calc_bottomright(size, src);
 311    layer->dst.tl = calc_topleft(size, dst);
 312    layer->dst.br = calc_bottomright(size, dst);
 313    layer->zw.x = 0.0f;
 314    layer->zw.y = size.y;
 315 }
 316
 317 static void
 318 set_yuv_layer(struct vl_compositor_state *s, struct vl_compositor *c,
 319               unsigned layer, struct pipe_video_buffer *buffer,
 320               struct u_rect *src_rect, struct u_rect *dst_rect,
 321               bool y, enum vl_compositor_deinterlace deinterlace)
 322 {
 323    struct pipe_sampler_view **sampler_views;
 324    float half_a_line;
 325    unsigned i;
 326
 327    assert(s && c && buffer);
 328
 329    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 330
 331    s->interlaced = buffer->interlaced;
 332    s->used_layers |= 1 << layer;
 333    sampler_views = buffer->get_sampler_view_components(buffer);
 334    for (i = 0; i < 3; ++i) {
 335       s->layers[layer].samplers[i] = c->sampler_linear;
 336       pipe_sampler_view_reference(&s->layers[layer].sampler_views[i], sampler_views[i]);
 337    }
 338
 339    calc_src_and_dst(&s->layers[layer], buffer->width, buffer->height,
 340                     src_rect ? *src_rect : default_rect(&s->layers[layer]),
 341                     dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
 342
 343    half_a_line = 0.5f / s->layers[layer].zw.y;
 344
 345    switch(deinterlace) {
 346    case VL_COMPOSITOR_BOB_TOP:
 347       s->layers[layer].zw.x = 0.0f;
 348       s->layers[layer].src.tl.y += half_a_line;
 349       s->layers[layer].src.br.y += half_a_line;
 350       if (c->pipe_gfx_supported)
 351           s->layers[layer].fs = (y) ? c->fs_yuv.bob.y : c->fs_yuv.bob.uv;
 352       if (c->pipe_cs_composit_supported)
 353           s->layers[layer].cs = (y) ? c->cs_yuv.bob.y : c->cs_yuv.bob.uv;
 354       break;
 355
 356    case VL_COMPOSITOR_BOB_BOTTOM:
 357       s->layers[layer].zw.x = 1.0f;
 358       s->layers[layer].src.tl.y -= half_a_line;
 359       s->layers[layer].src.br.y -= half_a_line;
 360       if (c->pipe_gfx_supported)
 361           s->layers[layer].fs = (y) ? c->fs_yuv.bob.y : c->fs_yuv.bob.uv;
 362       if (c->pipe_cs_composit_supported)
 363           s->layers[layer].cs = (y) ? c->cs_yuv.bob.y : c->cs_yuv.bob.uv;
 364       break;
 365
 366    default:
 367       if (c->pipe_gfx_supported)
 368           s->layers[layer].fs = (y) ? c->fs_yuv.weave.y : c->fs_yuv.weave.uv;
 369       if (c->pipe_cs_composit_supported)
 370           s->layers[layer].cs = (y) ? c->cs_yuv.weave.y : c->cs_yuv.weave.uv;
 371       break;
 372    }
 373 }
 374
 375 static void
 376 set_rgb_to_yuv_layer(struct vl_compositor_state *s, struct vl_compositor *c,
 377                      unsigned layer, struct pipe_sampler_view *v,
 378                      struct u_rect *src_rect, struct u_rect *dst_rect, bool y)
 379 {
 380    vl_csc_matrix csc_matrix;
 381
 382    assert(s && c && v);
 383
 384    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 385
 386    s->used_layers |= 1 << layer;
 387
 388    s->layers[layer].fs = y? c->fs_rgb_yuv.y : c->fs_rgb_yuv.uv;
 389
 390    vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_709_REV, NULL, false, &csc_matrix);
 391    vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix, 1.0f, 0.0f);
 392
 393    s->layers[layer].samplers[0] = c->sampler_linear;
 394    s->layers[layer].samplers[1] = NULL;
 395    s->layers[layer].samplers[2] = NULL;
 396
 397    pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], v);
 398    pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], NULL);
 399    pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
 400
 401    calc_src_and_dst(&s->layers[layer], v->texture->width0, v->texture->height0,
 402                     src_rect ? *src_rect : default_rect(&s->layers[layer]),
 403                     dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
 404 }
 405
 406 void
 407 vl_compositor_reset_dirty_area(struct u_rect *dirty)
 408 {
 409    assert(dirty);
 410
 411    dirty->x0 = dirty->y0 = VL_COMPOSITOR_MIN_DIRTY;
 412    dirty->x1 = dirty->y1 = VL_COMPOSITOR_MAX_DIRTY;
 413 }
 414
 415 void
 416 vl_compositor_set_clear_color(struct vl_compositor_state *s, union pipe_color_union *color)
 417 {
 418    assert(s);
 419    assert(color);
 420
 421    s->clear_color = *color;
 422 }
 423
 424 void
 425 vl_compositor_get_clear_color(struct vl_compositor_state *s, union pipe_color_union *color)
 426 {
 427    assert(s);
 428    assert(color);
 429
 430    *color = s->clear_color;
 431 }
 432
 433 void
 434 vl_compositor_clear_layers(struct vl_compositor_state *s)
 435 {
 436    unsigned i, j;
 437
 438    assert(s);
 439    s->interlaced = false;
 440    s->used_layers = 0;
 441    for ( i = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
 442       struct vertex4f v_one = { 1.0f, 1.0f, 1.0f, 1.0f };
 443       s->layers[i].clearing = i ? false : true;
 444       s->layers[i].blend = NULL;
 445       s->layers[i].fs = NULL;
 446       s->layers[i].cs = NULL;
 447       s->layers[i].viewport.scale[2] = 1;
 448       s->layers[i].viewport.translate[2] = 0;
 449       s->layers[i].rotate = VL_COMPOSITOR_ROTATE_0;
 450
 451       for ( j = 0; j < 3; j++)
 452          pipe_sampler_view_reference(&s->layers[i].sampler_views[j], NULL);
 453       for ( j = 0; j < 4; ++j)
 454          s->layers[i].colors[j] = v_one;
 455    }
 456 }
 457
 458 void
 459 vl_compositor_cleanup(struct vl_compositor *c)
 460 {
 461    assert(c);
 462
 463    cleanup_buffers(c);
 464    cleanup_shaders(c);
 465    cleanup_pipe_state(c);
 466 }
 467
 468 bool
 469 vl_compositor_set_csc_matrix(struct vl_compositor_state *s,
 470                              vl_csc_matrix const *matrix,
 471                              float luma_min, float luma_max)
 472 {
 473    struct pipe_transfer *buf_transfer;
 474
 475    assert(s);
 476
 477    float *ptr = pipe_buffer_map(s->pipe, s->shader_params,
 478                                PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
 479                                &buf_transfer);
 480
 481    if (!ptr)
 482       return false;
 483
 484    memcpy(ptr, matrix, sizeof(vl_csc_matrix));
 485
 486    ptr += sizeof(vl_csc_matrix)/sizeof(float);
 487    ptr[0] = luma_min;
 488    ptr[1] = luma_max;
 489
 490    pipe_buffer_unmap(s->pipe, buf_transfer);
 491
 492    return true;
 493 }
 494
 495 void
 496 vl_compositor_set_dst_clip(struct vl_compositor_state *s, struct u_rect *dst_clip)
 497 {
 498    assert(s);
 499
 500    s->scissor_valid = dst_clip != NULL;
 501    if (dst_clip) {
 502       s->scissor.minx = dst_clip->x0;
 503       s->scissor.miny = dst_clip->y0;
 504       s->scissor.maxx = dst_clip->x1;
 505       s->scissor.maxy = dst_clip->y1;
 506    }
 507 }
 508
 509 void
 510 vl_compositor_set_layer_blend(struct vl_compositor_state *s,
 511                               unsigned layer, void *blend,
 512                               bool is_clearing)
 513 {
 514    assert(s && blend);
 515
 516    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 517
 518    s->layers[layer].clearing = is_clearing;
 519    s->layers[layer].blend = blend;
 520 }
 521
 522 void
 523 vl_compositor_set_layer_dst_area(struct vl_compositor_state *s,
 524                                  unsigned layer, struct u_rect *dst_area)
 525 {
 526    assert(s);
 527
 528    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 529
 530    s->layers[layer].viewport_valid = dst_area != NULL;
 531    if (dst_area) {
 532       s->layers[layer].viewport.scale[0] = dst_area->x1 - dst_area->x0;
 533       s->layers[layer].viewport.scale[1] = dst_area->y1 - dst_area->y0;
 534       s->layers[layer].viewport.translate[0] = dst_area->x0;
 535       s->layers[layer].viewport.translate[1] = dst_area->y0;
 536    }
 537 }
 538
 539 void
 540 vl_compositor_set_buffer_layer(struct vl_compositor_state *s,
 541                                struct vl_compositor *c,
 542                                unsigned layer,
 543                                struct pipe_video_buffer *buffer,
 544                                struct u_rect *src_rect,
 545                                struct u_rect *dst_rect,
 546                                enum vl_compositor_deinterlace deinterlace)
 547 {
 548    struct pipe_sampler_view **sampler_views;
 549    unsigned i;
 550
 551    assert(s && c && buffer);
 552
 553    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 554
 555    s->interlaced = buffer->interlaced;
 556    s->used_layers |= 1 << layer;
 557    sampler_views = buffer->get_sampler_view_components(buffer);
 558    for (i = 0; i < 3; ++i) {
 559       s->layers[layer].samplers[i] = c->sampler_linear;
 560       pipe_sampler_view_reference(&s->layers[layer].sampler_views[i], sampler_views[i]);
 561    }
 562
 563    calc_src_and_dst(&s->layers[layer], buffer->width, buffer->height,
 564                     src_rect ? *src_rect : default_rect(&s->layers[layer]),
 565                     dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
 566
 567    if (buffer->interlaced) {
 568       float half_a_line = 0.5f / s->layers[layer].zw.y;
 569       switch(deinterlace) {
 570       case VL_COMPOSITOR_WEAVE:
 571          if (c->pipe_cs_composit_supported)
 572             s->layers[layer].cs = c->cs_weave_rgb;
 573          else if (c->pipe_gfx_supported)
 574             s->layers[layer].fs = c->fs_weave_rgb;
 575          break;
 576
 577       case VL_COMPOSITOR_BOB_TOP:
 578          s->layers[layer].zw.x = 0.0f;
 579          s->layers[layer].src.tl.y += half_a_line;
 580          s->layers[layer].src.br.y += half_a_line;
 581          if (c->pipe_cs_composit_supported)
 582             s->layers[layer].cs = c->cs_video_buffer;
 583          else if (c->pipe_gfx_supported)
 584             s->layers[layer].fs = c->fs_video_buffer;
 585          break;
 586
 587       case VL_COMPOSITOR_BOB_BOTTOM:
 588          s->layers[layer].zw.x = 1.0f;
 589          s->layers[layer].src.tl.y -= half_a_line;
 590          s->layers[layer].src.br.y -= half_a_line;
 591          if (c->pipe_cs_composit_supported)
 592             s->layers[layer].cs = c->cs_video_buffer;
 593          else if (c->pipe_gfx_supported)
 594             s->layers[layer].fs = c->fs_video_buffer;
 595          break;
 596       }
 597
 598    } else {
 599       if (c->pipe_cs_composit_supported)
 600          s->layers[layer].cs = c->cs_video_buffer;
 601       else if (c->pipe_gfx_supported)
 602          s->layers[layer].fs = c->fs_video_buffer;
 603    }
 604 }
 605
 606 void
 607 vl_compositor_set_palette_layer(struct vl_compositor_state *s,
 608                                 struct vl_compositor *c,
 609                                 unsigned layer,
 610                                 struct pipe_sampler_view *indexes,
 611                                 struct pipe_sampler_view *palette,
 612                                 struct u_rect *src_rect,
 613                                 struct u_rect *dst_rect,
 614                                 bool include_color_conversion)
 615 {
 616    assert(s && c && indexes && palette);
 617
 618    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 619
 620    s->used_layers |= 1 << layer;
 621
 622    s->layers[layer].fs = include_color_conversion ?
 623       c->fs_palette.yuv : c->fs_palette.rgb;
 624
 625    s->layers[layer].samplers[0] = c->sampler_linear;
 626    s->layers[layer].samplers[1] = c->sampler_nearest;
 627    s->layers[layer].samplers[2] = NULL;
 628    pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], indexes);
 629    pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], palette);
 630    pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
 631    calc_src_and_dst(&s->layers[layer], indexes->texture->width0, indexes->texture->height0,
 632                     src_rect ? *src_rect : default_rect(&s->layers[layer]),
 633                     dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
 634 }
 635
 636 void
 637 vl_compositor_set_rgba_layer(struct vl_compositor_state *s,
 638                              struct vl_compositor *c,
 639                              unsigned layer,
 640                              struct pipe_sampler_view *rgba,
 641                              struct u_rect *src_rect,
 642                              struct u_rect *dst_rect,
 643                              struct vertex4f *colors)
 644 {
 645    unsigned i;
 646
 647    assert(s && c && rgba);
 648
 649    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 650
 651    s->used_layers |= 1 << layer;
 652    s->layers[layer].fs = c->fs_rgba;
 653    s->layers[layer].samplers[0] = c->sampler_linear;
 654    s->layers[layer].samplers[1] = NULL;
 655    s->layers[layer].samplers[2] = NULL;
 656    pipe_sampler_view_reference(&s->layers[layer].sampler_views[0], rgba);
 657    pipe_sampler_view_reference(&s->layers[layer].sampler_views[1], NULL);
 658    pipe_sampler_view_reference(&s->layers[layer].sampler_views[2], NULL);
 659    calc_src_and_dst(&s->layers[layer], rgba->texture->width0, rgba->texture->height0,
 660                     src_rect ? *src_rect : default_rect(&s->layers[layer]),
 661                     dst_rect ? *dst_rect : default_rect(&s->layers[layer]));
 662
 663    if (colors)
 664       for (i = 0; i < 4; ++i)
 665          s->layers[layer].colors[i] = colors[i];
 666 }
 667
 668 void
 669 vl_compositor_set_layer_rotation(struct vl_compositor_state *s,
 670                                  unsigned layer,
 671                                  enum vl_compositor_rotation rotate)
 672 {
 673    assert(s);
 674    assert(layer < VL_COMPOSITOR_MAX_LAYERS);
 675    s->layers[layer].rotate = rotate;
 676 }
 677
 678 void
 679 vl_compositor_yuv_deint_full(struct vl_compositor_state *s,
 680                              struct vl_compositor *c,
 681                              struct pipe_video_buffer *src,
 682                              struct pipe_video_buffer *dst,
 683                              struct u_rect *src_rect,
 684                              struct u_rect *dst_rect,
 685                              enum vl_compositor_deinterlace deinterlace)
 686 {
 687    struct pipe_surface **dst_surfaces;
 688
 689    dst_surfaces = dst->get_surfaces(dst);
 690    vl_compositor_clear_layers(s);
 691
 692    set_yuv_layer(s, c, 0, src, src_rect, NULL, true, deinterlace);
 693    vl_compositor_set_layer_dst_area(s, 0, dst_rect);
 694    vl_compositor_render(s, c, dst_surfaces[0], NULL, false);
 695
 696    if (dst_rect) {
 697       dst_rect->x1 /= 2;
 698       dst_rect->y1 /= 2;
 699    }
 700
 701    set_yuv_layer(s, c, 0, src, src_rect, NULL, false, deinterlace);
 702    vl_compositor_set_layer_dst_area(s, 0, dst_rect);
 703    vl_compositor_render(s, c, dst_surfaces[1], NULL, false);
 704
 705    s->pipe->flush(s->pipe, NULL, 0);
 706 }
 707
 708 void
 709 vl_compositor_convert_rgb_to_yuv(struct vl_compositor_state *s,
 710                                  struct vl_compositor *c,
 711                                  unsigned layer,
 712                                  struct pipe_resource *src_res,
 713                                  struct pipe_video_buffer *dst,
 714                                  struct u_rect *src_rect,
 715                                  struct u_rect *dst_rect)
 716 {
 717    struct pipe_sampler_view *sv, sv_templ;
 718    struct pipe_surface **dst_surfaces;
 719
 720    dst_surfaces = dst->get_surfaces(dst);
 721
 722    memset(&sv_templ, 0, sizeof(sv_templ));
 723    u_sampler_view_default_template(&sv_templ, src_res, src_res->format);
 724    sv = s->pipe->create_sampler_view(s->pipe, src_res, &sv_templ);
 725
 726    vl_compositor_clear_layers(s);
 727
 728    set_rgb_to_yuv_layer(s, c, 0, sv, src_rect, NULL, true);
 729    vl_compositor_set_layer_dst_area(s, 0, dst_rect);
 730    vl_compositor_render(s, c, dst_surfaces[0], NULL, false);
 731
 732    if (dst_rect) {
 733       dst_rect->x1 /= 2;
 734       dst_rect->y1 /= 2;
 735    }
 736
 737    set_rgb_to_yuv_layer(s, c, 0, sv, src_rect, NULL, false);
 738    vl_compositor_set_layer_dst_area(s, 0, dst_rect);
 739    vl_compositor_render(s, c, dst_surfaces[1], NULL, false);
 740    pipe_sampler_view_reference(&sv, NULL);
 741
 742    s->pipe->flush(s->pipe, NULL, 0);
 743 }
 744
 745 void
 746 vl_compositor_render(struct vl_compositor_state *s,
 747                      struct vl_compositor       *c,
 748                      struct pipe_surface        *dst_surface,
 749                      struct u_rect              *dirty_area,
 750                      bool                        clear_dirty)
 751 {
 752    assert(s);
 753
 754    if (s->layers->cs)
 755       vl_compositor_cs_render(s, c, dst_surface, dirty_area, clear_dirty);
 756    else if (s->layers->fs)
 757       vl_compositor_gfx_render(s, c, dst_surface, dirty_area, clear_dirty);
 758    else
 759       debug_warning("Hardware don't support.\n");;
 760 }
 761
 762 bool
 763 vl_compositor_init(struct vl_compositor *c, struct pipe_context *pipe)
 764 {
 765    assert(c);
 766
 767    memset(c, 0, sizeof(*c));
 768
 769    c->pipe_cs_composit_supported = pipe->screen->get_param(pipe->screen, PIPE_CAP_PREFER_COMPUTE_FOR_MULTIMEDIA) &&
 770             pipe->screen->get_param(pipe->screen, PIPE_CAP_TGSI_TEX_TXF_LZ) &&
 771             pipe->screen->get_param(pipe->screen, PIPE_CAP_TGSI_DIV);
 772
 773    c->pipe_gfx_supported = pipe->screen->get_param(pipe->screen, PIPE_CAP_GRAPHICS);
 774    c->pipe = pipe;
 775
 776    if (!init_pipe_state(c)) {
 777       return false;
 778    }
 779
 780    if (!init_shaders(c)) {
 781       cleanup_pipe_state(c);
 782       return false;
 783    }
 784
 785    if (!init_buffers(c)) {
 786       cleanup_shaders(c);
 787       cleanup_pipe_state(c);
 788       return false;
 789    }
 790
 791    return true;
 792 }
 793
 794 bool
 795 vl_compositor_init_state(struct vl_compositor_state *s, struct pipe_context *pipe)
 796 {
 797    vl_csc_matrix csc_matrix;
 798
 799    assert(s);
 800
 801    memset(s, 0, sizeof(*s));
 802
 803    s->pipe = pipe;
 804
 805    s->clear_color.f[0] = s->clear_color.f[1] = 0.0f;
 806    s->clear_color.f[2] = s->clear_color.f[3] = 0.0f;
 807
 808    /*
 809     * Create our fragment shader's constant buffer
 810     * Const buffer contains the color conversion matrix and bias vectors
 811     */
 812    /* XXX: Create with IMMUTABLE/STATIC... although it does change every once in a long while... */
 813    s->shader_params = pipe_buffer_create_const0
 814    (
 815       pipe->screen,
 816       PIPE_BIND_CONSTANT_BUFFER,
 817       PIPE_USAGE_DEFAULT,
 818       sizeof(csc_matrix) + 6*sizeof(float) + 10*sizeof(int)
 819    );
 820
 821    if (!s->shader_params)
 822       return false;
 823
 824    vl_compositor_clear_layers(s);
 825
 826    vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, &csc_matrix);
 827    if (!vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix, 1.0f, 0.0f))
 828       return false;
 829
 830    return true;
 831 }
 832
 833 void
 834 vl_compositor_cleanup_state(struct vl_compositor_state *s)
 835 {
 836    assert(s);
 837
 838    vl_compositor_clear_layers(s);
 839    pipe_resource_reference(&s->shader_params, NULL);
 840 }