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 "vl_compositor.h"
  29 #include <assert.h>
  30 #include <pipe/p_context.h>
  31 #include <util/u_inlines.h>
  32 #include <tgsi/tgsi_parse.h>
  33 #include <tgsi/tgsi_build.h>
  34 #include <util/u_memory.h>
  35 #include "vl_csc.h"
  36 #include "vl_shader_build.h"
  37
  38 struct vertex2f
  39 {
  40    float x, y;
  41 };
  42
  43 struct vertex4f
  44 {
  45    float x, y, z, w;
  46 };
  47
  48 struct vertex_shader_consts
  49 {
  50    struct vertex4f dst_scale;
  51    struct vertex4f dst_trans;
  52    struct vertex4f src_scale;
  53    struct vertex4f src_trans;
  54 };
  55
  56 struct fragment_shader_consts
  57 {
  58    float matrix[16];
  59 };
  60
  61 /*
  62  * Represents 2 triangles in a strip in normalized coords.
  63  * Used to render the surface onto the frame buffer.
  64  */
  65 static const struct vertex2f surface_verts[4] =
  66 {
  67    {0.0f, 0.0f},
  68    {0.0f, 1.0f},
  69    {1.0f, 0.0f},
  70    {1.0f, 1.0f}
  71 };
  72
  73 /*
  74  * Represents texcoords for the above. We can use the position values directly.
  75  * TODO: Duplicate these in the shader, no need to create a buffer.
  76  */
  77 static const struct vertex2f *surface_texcoords = surface_verts;
  78
  79 static void
  80 create_vert_shader(struct vl_compositor *c)
  81 {
  82    const unsigned max_tokens = 50;
  83
  84    struct pipe_shader_state vs;
  85    struct tgsi_token *tokens;
  86    struct tgsi_header *header;
  87
  88    struct tgsi_full_declaration decl;
  89    struct tgsi_full_instruction inst;
  90
  91    unsigned ti;
  92
  93    unsigned i;
  94
  95    assert(c);
  96
  97    tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
  98    header = (struct tgsi_header*)&tokens[0];
  99    *header = tgsi_build_header();
 100    *(struct tgsi_processor*)&tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
 101
 102    ti = 2;
 103
 104    /*
 105     * decl i0             ; Vertex pos
 106     * decl i1             ; Vertex texcoords
 107     */
 108    for (i = 0; i < 2; i++) {
 109       decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
 110       ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 111    }
 112
 113    /*
 114     * decl c0             ; Scaling vector to scale vertex pos rect to destination size
 115     * decl c1             ; Translation vector to move vertex pos rect into position
 116     * decl c2             ; Scaling vector to scale texcoord rect to source size
 117     * decl c3             ; Translation vector to move texcoord rect into position
 118     */
 119    decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
 120    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 121
 122    /*
 123     * decl o0             ; Vertex pos
 124     * decl o1             ; Vertex texcoords
 125     */
 126    for (i = 0; i < 2; i++) {
 127       decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
 128       ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 129    }
 130
 131    /* decl t0, t1 */
 132    decl = vl_decl_temps(0, 1);
 133    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 134
 135    /*
 136     * mad o0, i0, c0, c1  ; Scale and translate unit output rect to destination size and pos
 137     * mad o1, i1, c2, c3  ; Scale and translate unit texcoord rect to source size and pos
 138     */
 139    for (i = 0; i < 2; ++i) {
 140       inst = vl_inst4(TGSI_OPCODE_MAD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
 141       ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 142    }
 143
 144    /* end */
 145    inst = vl_end();
 146    ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 147
 148    assert(ti <= max_tokens);
 149
 150    vs.tokens = tokens;
 151    c->vertex_shader = c->pipe->create_vs_state(c->pipe, &vs);
 152    FREE(tokens);
 153 }
 154
 155 static void
 156 create_frag_shader(struct vl_compositor *c)
 157 {
 158    const unsigned max_tokens = 50;
 159
 160    struct pipe_shader_state fs;
 161    struct tgsi_token *tokens;
 162    struct tgsi_header *header;
 163
 164    struct tgsi_full_declaration decl;
 165    struct tgsi_full_instruction inst;
 166
 167    unsigned ti;
 168
 169    unsigned i;
 170
 171    assert(c);
 172
 173    tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
 174    header = (struct tgsi_header*)&tokens[0];
 175    *header = tgsi_build_header();
 176    *(struct tgsi_processor*)&tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
 177
 178    ti = 2;
 179
 180    /* decl i0             ; Texcoords for s0 */
 181    decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, 1, 0, 0, TGSI_INTERPOLATE_LINEAR);
 182    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 183
 184    /*
 185     * decl c0-c3          ; CSC matrix c0-c3
 186     */
 187    decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
 188    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 189
 190    /* decl o0             ; Fragment color */
 191    decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
 192    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 193
 194    /* decl t0 */
 195    decl = vl_decl_temps(0, 0);
 196    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 197
 198    /* decl s0             ; Sampler for tex containing picture to display */
 199    decl = vl_decl_samplers(0, 0);
 200    ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
 201
 202    /* tex2d t0, i0, s0    ; Read src pixel */
 203    inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_SAMPLER, 0);
 204    ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 205
 206    /*
 207     * dp4 o0.x, t0, c0    ; Multiply pixel by the color conversion matrix
 208     * dp4 o0.y, t0, c1
 209     * dp4 o0.z, t0, c2
 210     * dp4 o0.w, t0, c3
 211     */
 212    for (i = 0; i < 4; ++i) {
 213       inst = vl_inst3(TGSI_OPCODE_DP4, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, i);
 214       inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_X << i;
 215       ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 216    }
 217
 218    /* end */
 219    inst = vl_end();
 220    ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 221
 222    assert(ti <= max_tokens);
 223
 224    fs.tokens = tokens;
 225    c->fragment_shader = c->pipe->create_fs_state(c->pipe, &fs);
 226    FREE(tokens);
 227 }
 228
 229 static bool
 230 init_pipe_state(struct vl_compositor *c)
 231 {
 232    struct pipe_sampler_state sampler;
 233    struct pipe_vertex_element vertex_elems[2];
 234
 235    assert(c);
 236
 237    c->fb_state.nr_cbufs = 1;
 238    c->fb_state.zsbuf = NULL;
 239
 240    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 241    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 242    sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 243    sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
 244    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 245    sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
 246    sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
 247    sampler.compare_func = PIPE_FUNC_ALWAYS;
 248    sampler.normalized_coords = 1;
 249    /*sampler.lod_bias = ;*/
 250    /*sampler.min_lod = ;*/
 251    /*sampler.max_lod = ;*/
 252    /*sampler.border_color[i] = ;*/
 253    /*sampler.max_anisotropy = ;*/
 254    c->sampler = c->pipe->create_sampler_state(c->pipe, &sampler);
 255
 256    vertex_elems[0].src_offset = 0;
 257    vertex_elems[0].instance_divisor = 0;
 258    vertex_elems[0].vertex_buffer_index = 0;
 259    vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
 260    vertex_elems[1].src_offset = 0;
 261    vertex_elems[1].instance_divisor = 0;
 262    vertex_elems[1].vertex_buffer_index = 1;
 263    vertex_elems[1].src_format = PIPE_FORMAT_R32G32_FLOAT;
 264    c->vertex_elems = c->pipe->create_vertex_elements_state(c->pipe, 2, vertex_elems);
 265
 266
 267    return true;
 268 }
 269
 270 static void cleanup_pipe_state(struct vl_compositor *c)
 271 {
 272    assert(c);
 273
 274    c->pipe->delete_sampler_state(c->pipe, c->sampler);
 275    c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems);
 276 }
 277
 278 static bool
 279 init_shaders(struct vl_compositor *c)
 280 {
 281    assert(c);
 282
 283    create_vert_shader(c);
 284    create_frag_shader(c);
 285
 286    return true;
 287 }
 288
 289 static void cleanup_shaders(struct vl_compositor *c)
 290 {
 291    assert(c);
 292
 293    c->pipe->delete_vs_state(c->pipe, c->vertex_shader);
 294    c->pipe->delete_fs_state(c->pipe, c->fragment_shader);
 295 }
 296
 297 static bool
 298 init_buffers(struct vl_compositor *c)
 299 {
 300    struct fragment_shader_consts fsc;
 301
 302    assert(c);
 303
 304    /*
 305     * Create our vertex buffer and vertex buffer element
 306     * VB contains 4 vertices that render a quad covering the entire window
 307     * to display a rendered surface
 308     * Quad is rendered as a tri strip
 309     */
 310    c->vertex_bufs[0].stride = sizeof(struct vertex2f);
 311    c->vertex_bufs[0].max_index = 3;
 312    c->vertex_bufs[0].buffer_offset = 0;
 313    c->vertex_bufs[0].buffer = pipe_buffer_create
 314    (
 315       c->pipe->screen,
 316       1,
 317       PIPE_BUFFER_USAGE_VERTEX,
 318       sizeof(struct vertex2f) * 4
 319    );
 320
 321    memcpy
 322    (
 323       pipe_buffer_map(c->pipe->screen, c->vertex_bufs[0].buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
 324       surface_verts,
 325       sizeof(struct vertex2f) * 4
 326    );
 327
 328    pipe_buffer_unmap(c->pipe->screen, c->vertex_bufs[0].buffer);
 329
 330    /*
 331     * Create our texcoord buffer and texcoord buffer element
 332     * Texcoord buffer contains the TCs for mapping the rendered surface to the 4 vertices
 333     */
 334    c->vertex_bufs[1].stride = sizeof(struct vertex2f);
 335    c->vertex_bufs[1].max_index = 3;
 336    c->vertex_bufs[1].buffer_offset = 0;
 337    c->vertex_bufs[1].buffer = pipe_buffer_create
 338    (
 339       c->pipe->screen,
 340       1,
 341       PIPE_BUFFER_USAGE_VERTEX,
 342       sizeof(struct vertex2f) * 4
 343    );
 344
 345    memcpy
 346    (
 347       pipe_buffer_map(c->pipe->screen, c->vertex_bufs[1].buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
 348       surface_texcoords,
 349       sizeof(struct vertex2f) * 4
 350    );
 351
 352    pipe_buffer_unmap(c->pipe->screen, c->vertex_bufs[1].buffer);
 353
 354    /*
 355     * Create our vertex shader's constant buffer
 356     * Const buffer contains scaling and translation vectors
 357     */
 358    c->vs_const_buf = pipe_buffer_create
 359    (
 360       c->pipe->screen,
 361       1,
 362       PIPE_BUFFER_USAGE_CONSTANT | PIPE_BUFFER_USAGE_DISCARD,
 363       sizeof(struct vertex_shader_consts)
 364    );
 365
 366    /*
 367     * Create our fragment shader's constant buffer
 368     * Const buffer contains the color conversion matrix and bias vectors
 369     */
 370    c->fs_const_buf = pipe_buffer_create
 371    (
 372       c->pipe->screen,
 373       1,
 374       PIPE_BUFFER_USAGE_CONSTANT,
 375       sizeof(struct fragment_shader_consts)
 376    );
 377
 378    vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, fsc.matrix);
 379
 380    vl_compositor_set_csc_matrix(c, fsc.matrix);
 381
 382    return true;
 383 }
 384
 385 static void
 386 cleanup_buffers(struct vl_compositor *c)
 387 {
 388    unsigned i;
 389
 390    assert(c);
 391
 392    for (i = 0; i < 2; ++i)
 393       pipe_buffer_reference(&c->vertex_bufs[i].buffer, NULL);
 394
 395    pipe_buffer_reference(&c->vs_const_buf, NULL);
 396    pipe_buffer_reference(&c->fs_const_buf, NULL);
 397 }
 398
 399 bool vl_compositor_init(struct vl_compositor *compositor, struct pipe_context *pipe)
 400 {
 401    assert(compositor);
 402
 403    memset(compositor, 0, sizeof(struct vl_compositor));
 404
 405    compositor->pipe = pipe;
 406
 407    if (!init_pipe_state(compositor))
 408       return false;
 409    if (!init_shaders(compositor)) {
 410       cleanup_pipe_state(compositor);
 411       return false;
 412    }
 413    if (!init_buffers(compositor)) {
 414       cleanup_shaders(compositor);
 415       cleanup_pipe_state(compositor);
 416       return false;
 417    }
 418
 419    return true;
 420 }
 421
 422 void vl_compositor_cleanup(struct vl_compositor *compositor)
 423 {
 424    assert(compositor);
 425
 426    cleanup_buffers(compositor);
 427    cleanup_shaders(compositor);
 428    cleanup_pipe_state(compositor);
 429 }
 430
 431 void vl_compositor_render(struct vl_compositor          *compositor,
 432                           /*struct pipe_texture         *backround,
 433                           struct pipe_video_rect        *backround_area,*/
 434                           struct pipe_texture           *src_surface,
 435                           enum pipe_mpeg12_picture_type picture_type,
 436                           /*unsigned                    num_past_surfaces,
 437                           struct pipe_texture           *past_surfaces,
 438                           unsigned                      num_future_surfaces,
 439                           struct pipe_texture           *future_surfaces,*/
 440                           struct pipe_video_rect        *src_area,
 441                           struct pipe_texture           *dst_surface,
 442                           struct pipe_video_rect        *dst_area,
 443                           /*unsigned                      num_layers,
 444                           struct pipe_texture           *layers,
 445                           struct pipe_video_rect        *layer_src_areas,
 446                           struct pipe_video_rect        *layer_dst_areas*/
 447                           struct pipe_fence_handle      **fence)
 448 {
 449    struct vertex_shader_consts *vs_consts;
 450
 451    assert(compositor);
 452    assert(src_surface);
 453    assert(src_area);
 454    assert(dst_surface);
 455    assert(dst_area);
 456    assert(picture_type == PIPE_MPEG12_PICTURE_TYPE_FRAME);
 457
 458    compositor->fb_state.width = dst_surface->width0;
 459    compositor->fb_state.height = dst_surface->height0;
 460    compositor->fb_state.cbufs[0] = compositor->pipe->screen->get_tex_surface
 461    (
 462       compositor->pipe->screen,
 463       dst_surface,
 464       0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE
 465    );
 466
 467    compositor->viewport.scale[0] = compositor->fb_state.width;
 468    compositor->viewport.scale[1] = compositor->fb_state.height;
 469    compositor->viewport.scale[2] = 1;
 470    compositor->viewport.scale[3] = 1;
 471    compositor->viewport.translate[0] = 0;
 472    compositor->viewport.translate[1] = 0;
 473    compositor->viewport.translate[2] = 0;
 474    compositor->viewport.translate[3] = 0;
 475
 476    compositor->scissor.maxx = compositor->fb_state.width;
 477    compositor->scissor.maxy = compositor->fb_state.height;
 478
 479    compositor->pipe->set_framebuffer_state(compositor->pipe, &compositor->fb_state);
 480    compositor->pipe->set_viewport_state(compositor->pipe, &compositor->viewport);
 481    compositor->pipe->set_scissor_state(compositor->pipe, &compositor->scissor);
 482    compositor->pipe->bind_fragment_sampler_states(compositor->pipe, 1, &compositor->sampler);
 483    compositor->pipe->set_fragment_sampler_textures(compositor->pipe, 1, &src_surface);
 484    compositor->pipe->bind_vs_state(compositor->pipe, compositor->vertex_shader);
 485    compositor->pipe->bind_fs_state(compositor->pipe, compositor->fragment_shader);
 486    compositor->pipe->set_vertex_buffers(compositor->pipe, 2, compositor->vertex_bufs);
 487    compositor->pipe->bind_vertex_elements_state(compositor->pipe, compositor->vertex_elems);
 488    compositor->pipe->set_constant_buffer(compositor->pipe, PIPE_SHADER_VERTEX, 0, compositor->vs_const_buf);
 489    compositor->pipe->set_constant_buffer(compositor->pipe, PIPE_SHADER_FRAGMENT, 0, compositor->fs_const_buf);
 490
 491    vs_consts = pipe_buffer_map
 492    (
 493       compositor->pipe->screen,
 494       compositor->vs_const_buf,
 495       PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
 496    );
 497
 498    vs_consts->dst_scale.x = dst_area->w / (float)compositor->fb_state.cbufs[0]->width;
 499    vs_consts->dst_scale.y = dst_area->h / (float)compositor->fb_state.cbufs[0]->height;
 500    vs_consts->dst_scale.z = 1;
 501    vs_consts->dst_scale.w = 1;
 502    vs_consts->dst_trans.x = dst_area->x / (float)compositor->fb_state.cbufs[0]->width;
 503    vs_consts->dst_trans.y = dst_area->y / (float)compositor->fb_state.cbufs[0]->height;
 504    vs_consts->dst_trans.z = 0;
 505    vs_consts->dst_trans.w = 0;
 506
 507    vs_consts->src_scale.x = src_area->w / (float)src_surface->width0;
 508    vs_consts->src_scale.y = src_area->h / (float)src_surface->height0;
 509    vs_consts->src_scale.z = 1;
 510    vs_consts->src_scale.w = 1;
 511    vs_consts->src_trans.x = src_area->x / (float)src_surface->width0;
 512    vs_consts->src_trans.y = src_area->y / (float)src_surface->height0;
 513    vs_consts->src_trans.z = 0;
 514    vs_consts->src_trans.w = 0;
 515
 516    pipe_buffer_unmap(compositor->pipe->screen, compositor->vs_const_buf);
 517
 518    compositor->pipe->draw_arrays(compositor->pipe, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
 519    compositor->pipe->flush(compositor->pipe, PIPE_FLUSH_RENDER_CACHE, fence);
 520
 521    pipe_surface_reference(&compositor->fb_state.cbufs[0], NULL);
 522 }
 523
 524 void vl_compositor_set_csc_matrix(struct vl_compositor *compositor, const float *mat)
 525 {
 526    assert(compositor);
 527
 528    memcpy
 529    (
 530       pipe_buffer_map(compositor->pipe->screen, compositor->fs_const_buf, PIPE_BUFFER_USAGE_CPU_WRITE),
 531       mat,
 532       sizeof(struct fragment_shader_consts)
 533    );
 534
 535    pipe_buffer_unmap(compositor->pipe->screen, compositor->fs_const_buf);
 536 }