src/gallium/auxiliary/vl/vl_mpeg12_decoder.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 <math.h>
  29 #include <assert.h>
  30
  31 #include "util/u_memory.h"
  32 #include "util/u_sampler.h"
  33 #include "util/u_surface.h"
  34 #include "util/u_video.h"
  35
  36 #include "vl_mpeg12_decoder.h"
  37 #include "vl_defines.h"
  38
  39 #define SCALE_FACTOR_SNORM (32768.0f / 256.0f)
  40 #define SCALE_FACTOR_SSCALED (1.0f / 256.0f)
  41
  42 struct format_config {
  43    enum pipe_format zscan_source_format;
  44    enum pipe_format idct_source_format;
  45    enum pipe_format mc_source_format;
  46
  47    float idct_scale;
  48    float mc_scale;
  49 };
  50
  51 static const struct format_config bitstream_format_config[] = {
  52 //   { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SSCALED },
  53 //   { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, 1.0f, SCALE_FACTOR_SSCALED },
  54    { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SNORM },
  55    { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, 1.0f, SCALE_FACTOR_SNORM }
  56 };
  57
  58 static const unsigned num_bitstream_format_configs =
  59    sizeof(bitstream_format_config) / sizeof(struct format_config);
  60
  61 static const struct format_config idct_format_config[] = {
  62 //   { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SSCALED },
  63 //   { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, 1.0f, SCALE_FACTOR_SSCALED },
  64    { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SNORM },
  65    { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, 1.0f, SCALE_FACTOR_SNORM }
  66 };
  67
  68 static const unsigned num_idct_format_configs =
  69    sizeof(idct_format_config) / sizeof(struct format_config);
  70
  71 static const struct format_config mc_format_config[] = {
  72    //{ PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_NONE, PIPE_FORMAT_R16_SSCALED, 0.0f, SCALE_FACTOR_SSCALED },
  73    { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_NONE, PIPE_FORMAT_R16_SNORM, 0.0f, SCALE_FACTOR_SNORM }
  74 };
  75
  76 static const unsigned num_mc_format_configs =
  77    sizeof(mc_format_config) / sizeof(struct format_config);
  78
  79 static const unsigned const_empty_block_mask_420[3][2][2] = {
  80    { { 0x20, 0x10 },  { 0x08, 0x04 } },
  81    { { 0x02, 0x02 },  { 0x02, 0x02 } },
  82    { { 0x01, 0x01 },  { 0x01, 0x01 } }
  83 };
  84
  85 struct video_buffer_private
  86 {
  87    struct list_head list;
  88    struct pipe_video_buffer *video_buffer;
  89
  90    struct pipe_sampler_view *sampler_view_planes[VL_NUM_COMPONENTS];
  91    struct pipe_surface      *surfaces[VL_MAX_SURFACES];
  92
  93    struct vl_mpeg12_buffer *buffer;
  94 };
  95
  96 static void
  97 vl_mpeg12_destroy_buffer(struct vl_mpeg12_buffer *buf);
  98
  99 static void
 100 destroy_video_buffer_private(void *private)
 101 {
 102    struct video_buffer_private *priv = private;
 103    unsigned i;
 104
 105    list_del(&priv->list);
 106
 107    for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 108       pipe_sampler_view_reference(&priv->sampler_view_planes[i], NULL);
 109
 110    for (i = 0; i < VL_MAX_SURFACES; ++i)
 111       pipe_surface_reference(&priv->surfaces[i], NULL);
 112
 113    if (priv->buffer)
 114       vl_mpeg12_destroy_buffer(priv->buffer);
 115
 116    FREE(priv);
 117 }
 118
 119 static struct video_buffer_private *
 120 get_video_buffer_private(struct vl_mpeg12_decoder *dec, struct pipe_video_buffer *buf)
 121 {
 122    struct pipe_context *pipe = dec->context;
 123    struct video_buffer_private *priv;
 124    struct pipe_sampler_view **sv;
 125    struct pipe_surface **surf;
 126    unsigned i;
 127
 128    priv = vl_video_buffer_get_associated_data(buf, &dec->base);
 129    if (priv)
 130       return priv;
 131
 132    priv = CALLOC_STRUCT(video_buffer_private);
 133
 134    list_add(&priv->list, &dec->buffer_privates);
 135    priv->video_buffer = buf;
 136
 137    sv = buf->get_sampler_view_planes(buf);
 138    for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 139       if (sv[i])
 140          priv->sampler_view_planes[i] = pipe->create_sampler_view(pipe, sv[i]->texture, sv[i]);
 141
 142    surf = buf->get_surfaces(buf);
 143    for (i = 0; i < VL_MAX_SURFACES; ++i)
 144       if (surf[i])
 145          priv->surfaces[i] = pipe->create_surface(pipe, surf[i]->texture, surf[i]);
 146
 147    vl_video_buffer_set_associated_data(buf, &dec->base, priv, destroy_video_buffer_private);
 148
 149    return priv;
 150 }
 151
 152 static void
 153 free_video_buffer_privates(struct vl_mpeg12_decoder *dec)
 154 {
 155    struct video_buffer_private *priv, *next;
 156
 157    LIST_FOR_EACH_ENTRY_SAFE(priv, next, &dec->buffer_privates, list) {
 158       struct pipe_video_buffer *buf = priv->video_buffer;
 159
 160       vl_video_buffer_set_associated_data(buf, &dec->base, NULL, NULL);
 161    }
 162 }
 163
 164 static bool
 165 init_zscan_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buffer)
 166 {
 167    struct pipe_resource *res, res_tmpl;
 168    struct pipe_sampler_view sv_tmpl;
 169    struct pipe_surface **destination;
 170
 171    unsigned i;
 172
 173    assert(dec && buffer);
 174
 175    memset(&res_tmpl, 0, sizeof(res_tmpl));
 176    res_tmpl.target = PIPE_TEXTURE_2D;
 177    res_tmpl.format = dec->zscan_source_format;
 178    res_tmpl.width0 = dec->blocks_per_line * VL_BLOCK_WIDTH * VL_BLOCK_HEIGHT;
 179    res_tmpl.height0 = align(dec->num_blocks, dec->blocks_per_line) / dec->blocks_per_line;
 180    res_tmpl.depth0 = 1;
 181    res_tmpl.array_size = 1;
 182    res_tmpl.usage = PIPE_USAGE_STREAM;
 183    res_tmpl.bind = PIPE_BIND_SAMPLER_VIEW;
 184
 185    res = dec->context->screen->resource_create(dec->context->screen, &res_tmpl);
 186    if (!res)
 187       goto error_source;
 188
 189
 190    memset(&sv_tmpl, 0, sizeof(sv_tmpl));
 191    u_sampler_view_default_template(&sv_tmpl, res, res->format);
 192    sv_tmpl.swizzle_r = sv_tmpl.swizzle_g = sv_tmpl.swizzle_b = sv_tmpl.swizzle_a = PIPE_SWIZZLE_X;
 193    buffer->zscan_source = dec->context->create_sampler_view(dec->context, res, &sv_tmpl);
 194    pipe_resource_reference(&res, NULL);
 195    if (!buffer->zscan_source)
 196       goto error_sampler;
 197
 198    if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
 199       destination = dec->idct_source->get_surfaces(dec->idct_source);
 200    else
 201       destination = dec->mc_source->get_surfaces(dec->mc_source);
 202
 203    if (!destination)
 204       goto error_surface;
 205
 206    for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 207       if (!vl_zscan_init_buffer(i == 0 ? &dec->zscan_y : &dec->zscan_c,
 208                                 &buffer->zscan[i], buffer->zscan_source, destination[i]))
 209          goto error_plane;
 210
 211    return true;
 212
 213 error_plane:
 214    for (; i > 0; --i)
 215       vl_zscan_cleanup_buffer(&buffer->zscan[i - 1]);
 216
 217 error_surface:
 218 error_sampler:
 219    pipe_sampler_view_reference(&buffer->zscan_source, NULL);
 220
 221 error_source:
 222    return false;
 223 }
 224
 225 static void
 226 cleanup_zscan_buffer(struct vl_mpeg12_buffer *buffer)
 227 {
 228    unsigned i;
 229
 230    assert(buffer);
 231
 232    for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 233       vl_zscan_cleanup_buffer(&buffer->zscan[i]);
 234
 235    pipe_sampler_view_reference(&buffer->zscan_source, NULL);
 236 }
 237
 238 static bool
 239 init_idct_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buffer)
 240 {
 241    struct pipe_sampler_view **idct_source_sv, **mc_source_sv;
 242
 243    unsigned i;
 244
 245    assert(dec && buffer);
 246
 247    idct_source_sv = dec->idct_source->get_sampler_view_planes(dec->idct_source);
 248    if (!idct_source_sv)
 249       goto error_source_sv;
 250
 251    mc_source_sv = dec->mc_source->get_sampler_view_planes(dec->mc_source);
 252    if (!mc_source_sv)
 253       goto error_mc_source_sv;
 254
 255    for (i = 0; i < 3; ++i)
 256       if (!vl_idct_init_buffer(i == 0 ? &dec->idct_y : &dec->idct_c,
 257                                &buffer->idct[i], idct_source_sv[i],
 258                                mc_source_sv[i]))
 259          goto error_plane;
 260
 261    return true;
 262
 263 error_plane:
 264    for (; i > 0; --i)
 265       vl_idct_cleanup_buffer(&buffer->idct[i - 1]);
 266
 267 error_mc_source_sv:
 268 error_source_sv:
 269    return false;
 270 }
 271
 272 static void
 273 cleanup_idct_buffer(struct vl_mpeg12_buffer *buf)
 274 {
 275    unsigned i;
 276
 277    assert(buf);
 278
 279    for (i = 0; i < 3; ++i)
 280       vl_idct_cleanup_buffer(&buf->idct[i]);
 281 }
 282
 283 static bool
 284 init_mc_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buf)
 285 {
 286    assert(dec && buf);
 287
 288    if(!vl_mc_init_buffer(&dec->mc_y, &buf->mc[0]))
 289       goto error_mc_y;
 290
 291    if(!vl_mc_init_buffer(&dec->mc_c, &buf->mc[1]))
 292       goto error_mc_cb;
 293
 294    if(!vl_mc_init_buffer(&dec->mc_c, &buf->mc[2]))
 295       goto error_mc_cr;
 296
 297    return true;
 298
 299 error_mc_cr:
 300    vl_mc_cleanup_buffer(&buf->mc[1]);
 301
 302 error_mc_cb:
 303    vl_mc_cleanup_buffer(&buf->mc[0]);
 304
 305 error_mc_y:
 306    return false;
 307 }
 308
 309 static void
 310 cleanup_mc_buffer(struct vl_mpeg12_buffer *buf)
 311 {
 312    unsigned i;
 313
 314    assert(buf);
 315
 316    for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 317       vl_mc_cleanup_buffer(&buf->mc[i]);
 318 }
 319
 320 static inline void
 321 MacroBlockTypeToPipeWeights(const struct pipe_mpeg12_macroblock *mb, unsigned weights[2])
 322 {
 323    assert(mb);
 324
 325    switch (mb->macroblock_type & (PIPE_MPEG12_MB_TYPE_MOTION_FORWARD | PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD)) {
 326    case PIPE_MPEG12_MB_TYPE_MOTION_FORWARD:
 327       weights[0] = PIPE_VIDEO_MV_WEIGHT_MAX;
 328       weights[1] = PIPE_VIDEO_MV_WEIGHT_MIN;
 329       break;
 330
 331    case (PIPE_MPEG12_MB_TYPE_MOTION_FORWARD | PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD):
 332       weights[0] = PIPE_VIDEO_MV_WEIGHT_HALF;
 333       weights[1] = PIPE_VIDEO_MV_WEIGHT_HALF;
 334       break;
 335
 336    case PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD:
 337       weights[0] = PIPE_VIDEO_MV_WEIGHT_MIN;
 338       weights[1] = PIPE_VIDEO_MV_WEIGHT_MAX;
 339       break;
 340
 341    default:
 342       if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
 343          weights[0] = PIPE_VIDEO_MV_WEIGHT_MIN;
 344          weights[1] = PIPE_VIDEO_MV_WEIGHT_MIN;
 345       } else {
 346          /* no motion vector, but also not intra mb ->
 347             just copy the old frame content */
 348          weights[0] = PIPE_VIDEO_MV_WEIGHT_MAX;
 349          weights[1] = PIPE_VIDEO_MV_WEIGHT_MIN;
 350       }
 351       break;
 352    }
 353 }
 354
 355 static inline struct vl_motionvector
 356 MotionVectorToPipe(const struct pipe_mpeg12_macroblock *mb, unsigned vector,
 357                    unsigned field_select_mask, unsigned weight)
 358 {
 359    struct vl_motionvector mv;
 360
 361    assert(mb);
 362
 363    if (mb->macroblock_type & (PIPE_MPEG12_MB_TYPE_MOTION_FORWARD | PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD)) {
 364       switch (mb->macroblock_modes.bits.frame_motion_type) {
 365       case PIPE_MPEG12_MO_TYPE_FRAME:
 366          mv.top.x = mb->PMV[0][vector][0];
 367          mv.top.y = mb->PMV[0][vector][1];
 368          mv.top.field_select = PIPE_VIDEO_FRAME;
 369          mv.top.weight = weight;
 370
 371          mv.bottom.x = mb->PMV[0][vector][0];
 372          mv.bottom.y = mb->PMV[0][vector][1];
 373          mv.bottom.weight = weight;
 374          mv.bottom.field_select = PIPE_VIDEO_FRAME;
 375          break;
 376
 377       case PIPE_MPEG12_MO_TYPE_FIELD:
 378          mv.top.x = mb->PMV[0][vector][0];
 379          mv.top.y = mb->PMV[0][vector][1];
 380          mv.top.field_select = (mb->motion_vertical_field_select & field_select_mask) ?
 381             PIPE_VIDEO_BOTTOM_FIELD : PIPE_VIDEO_TOP_FIELD;
 382          mv.top.weight = weight;
 383
 384          mv.bottom.x = mb->PMV[1][vector][0];
 385          mv.bottom.y = mb->PMV[1][vector][1];
 386          mv.bottom.field_select = (mb->motion_vertical_field_select & (field_select_mask << 2)) ?
 387             PIPE_VIDEO_BOTTOM_FIELD : PIPE_VIDEO_TOP_FIELD;
 388          mv.bottom.weight = weight;
 389          break;
 390
 391       default: // TODO: Support DUALPRIME and 16x8
 392          break;
 393       }
 394    } else {
 395       mv.top.x = mv.top.y = 0;
 396       mv.top.field_select = PIPE_VIDEO_FRAME;
 397       mv.top.weight = weight;
 398
 399       mv.bottom.x = mv.bottom.y = 0;
 400       mv.bottom.field_select = PIPE_VIDEO_FRAME;
 401       mv.bottom.weight = weight;
 402    }
 403    return mv;
 404 }
 405
 406 static inline void
 407 UploadYcbcrBlocks(struct vl_mpeg12_decoder *dec,
 408                   struct vl_mpeg12_buffer *buf,
 409                   const struct pipe_mpeg12_macroblock *mb)
 410 {
 411    unsigned intra;
 412    unsigned tb, x, y, num_blocks = 0;
 413
 414    assert(dec && buf);
 415    assert(mb);
 416
 417    if (!mb->coded_block_pattern)
 418       return;
 419
 420    intra = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA ? 1 : 0;
 421
 422    for (y = 0; y < 2; ++y) {
 423       for (x = 0; x < 2; ++x) {
 424          if (mb->coded_block_pattern & const_empty_block_mask_420[0][y][x]) {
 425
 426             struct vl_ycbcr_block *stream = buf->ycbcr_stream[0];
 427             stream->x = mb->x * 2 + x;
 428             stream->y = mb->y * 2 + y;
 429             stream->intra = intra;
 430             stream->coding = mb->macroblock_modes.bits.dct_type;
 431             stream->block_num = buf->block_num++;
 432
 433             buf->num_ycbcr_blocks[0]++;
 434             buf->ycbcr_stream[0]++;
 435
 436             num_blocks++;
 437          }
 438       }
 439    }
 440
 441    /* TODO: Implement 422, 444 */
 442    //assert(ctx->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
 443
 444    for (tb = 1; tb < 3; ++tb) {
 445       if (mb->coded_block_pattern & const_empty_block_mask_420[tb][0][0]) {
 446
 447          struct vl_ycbcr_block *stream = buf->ycbcr_stream[tb];
 448          stream->x = mb->x;
 449          stream->y = mb->y;
 450          stream->intra = intra;
 451          stream->coding = 0;
 452          stream->block_num = buf->block_num++;
 453
 454          buf->num_ycbcr_blocks[tb]++;
 455          buf->ycbcr_stream[tb]++;
 456
 457          num_blocks++;
 458       }
 459    }
 460
 461    memcpy(buf->texels, mb->blocks, 64 * sizeof(short) * num_blocks);
 462    buf->texels += 64 * num_blocks;
 463 }
 464
 465 static void
 466 vl_mpeg12_destroy_buffer(struct vl_mpeg12_buffer *buf)
 467 {
 468
 469    assert(buf);
 470
 471    cleanup_zscan_buffer(buf);
 472    cleanup_idct_buffer(buf);
 473    cleanup_mc_buffer(buf);
 474    vl_vb_cleanup(&buf->vertex_stream);
 475
 476    FREE(buf);
 477 }
 478
 479 static void
 480 vl_mpeg12_destroy(struct pipe_video_codec *decoder)
 481 {
 482    struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder*)decoder;
 483    unsigned i;
 484
 485    assert(decoder);
 486
 487    free_video_buffer_privates(dec);
 488
 489    /* Asserted in softpipe_delete_fs_state() for some reason */
 490    dec->context->bind_vs_state(dec->context, NULL);
 491    dec->context->bind_fs_state(dec->context, NULL);
 492
 493    dec->context->delete_depth_stencil_alpha_state(dec->context, dec->dsa);
 494    dec->context->delete_sampler_state(dec->context, dec->sampler_ycbcr);
 495
 496    vl_mc_cleanup(&dec->mc_y);
 497    vl_mc_cleanup(&dec->mc_c);
 498    dec->mc_source->destroy(dec->mc_source);
 499
 500    if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
 501       vl_idct_cleanup(&dec->idct_y);
 502       vl_idct_cleanup(&dec->idct_c);
 503       dec->idct_source->destroy(dec->idct_source);
 504    }
 505
 506    vl_zscan_cleanup(&dec->zscan_y);
 507    vl_zscan_cleanup(&dec->zscan_c);
 508
 509    dec->context->delete_vertex_elements_state(dec->context, dec->ves_ycbcr);
 510    dec->context->delete_vertex_elements_state(dec->context, dec->ves_mv);
 511
 512    pipe_resource_reference(&dec->quads.buffer.resource, NULL);
 513    pipe_resource_reference(&dec->pos.buffer.resource, NULL);
 514
 515    pipe_sampler_view_reference(&dec->zscan_linear, NULL);
 516    pipe_sampler_view_reference(&dec->zscan_normal, NULL);
 517    pipe_sampler_view_reference(&dec->zscan_alternate, NULL);
 518
 519    for (i = 0; i < 4; ++i)
 520       if (dec->dec_buffers[i])
 521          vl_mpeg12_destroy_buffer(dec->dec_buffers[i]);
 522
 523    dec->context->destroy(dec->context);
 524
 525    FREE(dec);
 526 }
 527
 528 static struct vl_mpeg12_buffer *
 529 vl_mpeg12_get_decode_buffer(struct vl_mpeg12_decoder *dec, struct pipe_video_buffer *target)
 530 {
 531    struct video_buffer_private *priv;
 532    struct vl_mpeg12_buffer *buffer;
 533
 534    assert(dec);
 535
 536    priv = get_video_buffer_private(dec, target);
 537    if (priv->buffer)
 538       return priv->buffer;
 539
 540    buffer = dec->dec_buffers[dec->current_buffer];
 541    if (buffer)
 542       return buffer;
 543
 544    buffer = CALLOC_STRUCT(vl_mpeg12_buffer);
 545    if (!buffer)
 546       return NULL;
 547
 548    if (!vl_vb_init(&buffer->vertex_stream, dec->context,
 549                    dec->base.width / VL_MACROBLOCK_WIDTH,
 550                    dec->base.height / VL_MACROBLOCK_HEIGHT))
 551       goto error_vertex_buffer;
 552
 553    if (!init_mc_buffer(dec, buffer))
 554       goto error_mc;
 555
 556    if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
 557       if (!init_idct_buffer(dec, buffer))
 558          goto error_idct;
 559
 560    if (!init_zscan_buffer(dec, buffer))
 561       goto error_zscan;
 562
 563    if (dec->base.entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM)
 564       vl_mpg12_bs_init(&buffer->bs, &dec->base);
 565
 566    if (dec->base.expect_chunked_decode)
 567       priv->buffer = buffer;
 568    else
 569       dec->dec_buffers[dec->current_buffer] = buffer;
 570
 571    return buffer;
 572
 573 error_zscan:
 574    cleanup_idct_buffer(buffer);
 575
 576 error_idct:
 577    cleanup_mc_buffer(buffer);
 578
 579 error_mc:
 580    vl_vb_cleanup(&buffer->vertex_stream);
 581
 582 error_vertex_buffer:
 583    FREE(buffer);
 584    return NULL;
 585 }
 586
 587 static void
 588 vl_mpeg12_begin_frame(struct pipe_video_codec *decoder,
 589                       struct pipe_video_buffer *target,
 590                       struct pipe_picture_desc *picture)
 591 {
 592    struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder;
 593    struct pipe_mpeg12_picture_desc *desc = (struct pipe_mpeg12_picture_desc *)picture;
 594    struct vl_mpeg12_buffer *buf;
 595
 596    struct pipe_resource *tex;
 597    struct pipe_box rect = { 0, 0, 0, 1, 1, 1 };
 598
 599    uint8_t intra_matrix[64];
 600    uint8_t non_intra_matrix[64];
 601
 602    unsigned i;
 603
 604    assert(dec && target && picture);
 605
 606    buf = vl_mpeg12_get_decode_buffer(dec, target);
 607    assert(buf);
 608
 609    if (dec->base.entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
 610       memcpy(intra_matrix, desc->intra_matrix, sizeof(intra_matrix));
 611       memcpy(non_intra_matrix, desc->non_intra_matrix, sizeof(non_intra_matrix));
 612       intra_matrix[0] = 1 << (7 - desc->intra_dc_precision);
 613    } else {
 614       memset(intra_matrix, 0x10, sizeof(intra_matrix));
 615       memset(non_intra_matrix, 0x10, sizeof(non_intra_matrix));
 616    }
 617
 618    for (i = 0; i < VL_NUM_COMPONENTS; ++i) {
 619       struct vl_zscan *zscan = i == 0 ? &dec->zscan_y : &dec->zscan_c;
 620       vl_zscan_upload_quant(zscan, &buf->zscan[i], intra_matrix, true);
 621       vl_zscan_upload_quant(zscan, &buf->zscan[i], non_intra_matrix, false);
 622    }
 623
 624    vl_vb_map(&buf->vertex_stream, dec->context);
 625
 626    tex = buf->zscan_source->texture;
 627    rect.width = tex->width0;
 628    rect.height = tex->height0;
 629
 630    buf->texels =
 631       dec->context->transfer_map(dec->context, tex, 0,
 632                                  PIPE_TRANSFER_WRITE |
 633                                  PIPE_TRANSFER_DISCARD_RANGE,
 634                                  &rect, &buf->tex_transfer);
 635
 636    buf->block_num = 0;
 637
 638    for (i = 0; i < VL_NUM_COMPONENTS; ++i) {
 639       buf->ycbcr_stream[i] = vl_vb_get_ycbcr_stream(&buf->vertex_stream, i);
 640       buf->num_ycbcr_blocks[i] = 0;
 641    }
 642
 643    for (i = 0; i < VL_MAX_REF_FRAMES; ++i)
 644       buf->mv_stream[i] = vl_vb_get_mv_stream(&buf->vertex_stream, i);
 645
 646    if (dec->base.entrypoint >= PIPE_VIDEO_ENTRYPOINT_IDCT) {
 647       for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 648          vl_zscan_set_layout(&buf->zscan[i], dec->zscan_linear);
 649    }
 650 }
 651
 652 static void
 653 vl_mpeg12_decode_macroblock(struct pipe_video_codec *decoder,
 654                             struct pipe_video_buffer *target,
 655                             struct pipe_picture_desc *picture,
 656                             const struct pipe_macroblock *macroblocks,
 657                             unsigned num_macroblocks)
 658 {
 659    struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder;
 660    const struct pipe_mpeg12_macroblock *mb = (const struct pipe_mpeg12_macroblock *)macroblocks;
 661    struct pipe_mpeg12_picture_desc *desc = (struct pipe_mpeg12_picture_desc *)picture;
 662    struct vl_mpeg12_buffer *buf;
 663
 664    unsigned i, j, mv_weights[2];
 665
 666    assert(dec && target && picture);
 667    assert(macroblocks && macroblocks->codec == PIPE_VIDEO_FORMAT_MPEG12);
 668
 669    buf = vl_mpeg12_get_decode_buffer(dec, target);
 670    assert(buf);
 671
 672    for (; num_macroblocks > 0; --num_macroblocks) {
 673       unsigned mb_addr = mb->y * dec->width_in_macroblocks + mb->x;
 674
 675       if (mb->macroblock_type & (PIPE_MPEG12_MB_TYPE_PATTERN | PIPE_MPEG12_MB_TYPE_INTRA))
 676          UploadYcbcrBlocks(dec, buf, mb);
 677
 678       MacroBlockTypeToPipeWeights(mb, mv_weights);
 679
 680       for (i = 0; i < 2; ++i) {
 681           if (!desc->ref[i]) continue;
 682
 683          buf->mv_stream[i][mb_addr] = MotionVectorToPipe
 684          (
 685             mb, i,
 686             i ? PIPE_MPEG12_FS_FIRST_BACKWARD : PIPE_MPEG12_FS_FIRST_FORWARD,
 687             mv_weights[i]
 688          );
 689       }
 690
 691       /* see section 7.6.6 of the spec */
 692       if (mb->num_skipped_macroblocks > 0) {
 693          struct vl_motionvector skipped_mv[2];
 694
 695          if (desc->ref[0] && !desc->ref[1]) {
 696             skipped_mv[0].top.x = skipped_mv[0].top.y = 0;
 697             skipped_mv[0].top.weight = PIPE_VIDEO_MV_WEIGHT_MAX;
 698          } else {
 699            skipped_mv[0] = buf->mv_stream[0][mb_addr];
 700            skipped_mv[1] = buf->mv_stream[1][mb_addr];
 701          }
 702          skipped_mv[0].top.field_select = PIPE_VIDEO_FRAME;
 703          skipped_mv[1].top.field_select = PIPE_VIDEO_FRAME;
 704
 705          skipped_mv[0].bottom = skipped_mv[0].top;
 706          skipped_mv[1].bottom = skipped_mv[1].top;
 707
 708          ++mb_addr;
 709          for (i = 0; i < mb->num_skipped_macroblocks; ++i, ++mb_addr) {
 710             for (j = 0; j < 2; ++j) {
 711                if (!desc->ref[j]) continue;
 712                buf->mv_stream[j][mb_addr] = skipped_mv[j];
 713
 714             }
 715          }
 716       }
 717
 718       ++mb;
 719    }
 720 }
 721
 722 static void
 723 vl_mpeg12_decode_bitstream(struct pipe_video_codec *decoder,
 724                            struct pipe_video_buffer *target,
 725                            struct pipe_picture_desc *picture,
 726                            unsigned num_buffers,
 727                            const void * const *buffers,
 728                            const unsigned *sizes)
 729 {
 730    struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder;
 731    struct pipe_mpeg12_picture_desc *desc = (struct pipe_mpeg12_picture_desc *)picture;
 732    struct vl_mpeg12_buffer *buf;
 733
 734    unsigned i;
 735
 736    assert(dec && target && picture);
 737
 738    buf = vl_mpeg12_get_decode_buffer(dec, target);
 739    assert(buf);
 740
 741    for (i = 0; i < VL_NUM_COMPONENTS; ++i)
 742       vl_zscan_set_layout(&buf->zscan[i], desc->alternate_scan ?
 743                           dec->zscan_alternate : dec->zscan_normal);
 744
 745    vl_mpg12_bs_decode(&buf->bs, target, desc, num_buffers, buffers, sizes);
 746 }
 747
 748 static void
 749 vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
 750                     struct pipe_video_buffer *target,
 751                     struct pipe_picture_desc *picture)
 752 {
 753    struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder;
 754    struct pipe_mpeg12_picture_desc *desc = (struct pipe_mpeg12_picture_desc *)picture;
 755    struct pipe_sampler_view **ref_frames[2];
 756    struct pipe_sampler_view **mc_source_sv;
 757    struct pipe_surface **target_surfaces;
 758    struct pipe_vertex_buffer vb[3];
 759    struct vl_mpeg12_buffer *buf;
 760
 761    const unsigned *plane_order;
 762    unsigned i, j, component;
 763    unsigned nr_components;
 764
 765    assert(dec && target && picture);
 766    assert(!target->interlaced);
 767
 768    buf = vl_mpeg12_get_decode_buffer(dec, target);
 769
 770    vl_vb_unmap(&buf->vertex_stream, dec->context);
 771
 772    dec->context->transfer_unmap(dec->context, buf->tex_transfer);
 773
 774    vb[0] = dec->quads;
 775    vb[1] = dec->pos;
 776
 777    target_surfaces = get_video_buffer_private(dec, target)->surfaces;
 778
 779    for (i = 0; i < VL_MAX_REF_FRAMES; ++i) {
 780       if (desc->ref[i])
 781          ref_frames[i] = get_video_buffer_private(dec, desc->ref[i])->sampler_view_planes;
 782       else
 783          ref_frames[i] = NULL;
 784    }
 785
 786    dec->context->bind_vertex_elements_state(dec->context, dec->ves_mv);
 787    for (i = 0; i < VL_NUM_COMPONENTS; ++i) {
 788       if (!target_surfaces[i]) continue;
 789
 790       vl_mc_set_surface(&buf->mc[i], target_surfaces[i]);
 791
 792       for (j = 0; j < VL_MAX_REF_FRAMES; ++j) {
 793          if (!ref_frames[j] || !ref_frames[j][i]) continue;
 794
 795          vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);
 796          dec->context->set_vertex_buffers(dec->context, 0, 3, vb);
 797
 798          vl_mc_render_ref(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], ref_frames[j][i]);
 799       }
 800    }
 801
 802    dec->context->bind_vertex_elements_state(dec->context, dec->ves_ycbcr);
 803    for (i = 0; i < VL_NUM_COMPONENTS; ++i) {
 804       if (!buf->num_ycbcr_blocks[i]) continue;
 805
 806       vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, i);
 807       dec->context->set_vertex_buffers(dec->context, 0, 2, vb);
 808
 809       vl_zscan_render(i ? &dec->zscan_c : & dec->zscan_y, &buf->zscan[i] , buf->num_ycbcr_blocks[i]);
 810
 811       if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
 812          vl_idct_flush(i ? &dec->idct_c : &dec->idct_y, &buf->idct[i], buf->num_ycbcr_blocks[i]);
 813    }
 814
 815    plane_order = vl_video_buffer_plane_order(target->buffer_format);
 816    mc_source_sv = dec->mc_source->get_sampler_view_planes(dec->mc_source);
 817    for (i = 0, component = 0; component < VL_NUM_COMPONENTS; ++i) {
 818       if (!target_surfaces[i]) continue;
 819
 820       nr_components = util_format_get_nr_components(target_surfaces[i]->texture->format);
 821       for (j = 0; j < nr_components; ++j, ++component) {
 822          unsigned plane = plane_order[component];
 823          if (!buf->num_ycbcr_blocks[plane]) continue;
 824
 825          vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, plane);
 826          dec->context->set_vertex_buffers(dec->context, 0, 2, vb);
 827
 828          if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
 829             vl_idct_prepare_stage2(i ? &dec->idct_c : &dec->idct_y, &buf->idct[plane]);
 830          else {
 831             dec->context->set_sampler_views(dec->context,
 832                                             PIPE_SHADER_FRAGMENT, 0, 1,
 833                                             &mc_source_sv[plane]);
 834             dec->context->bind_sampler_states(dec->context,
 835                                               PIPE_SHADER_FRAGMENT,
 836                                               0, 1, &dec->sampler_ycbcr);
 837          }
 838          vl_mc_render_ycbcr(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], j, buf->num_ycbcr_blocks[plane]);
 839       }
 840    }
 841    dec->context->flush(dec->context, NULL, 0);
 842    ++dec->current_buffer;
 843    dec->current_buffer %= 4;
 844 }
 845
 846 static void
 847 vl_mpeg12_flush(struct pipe_video_codec *decoder)
 848 {
 849    assert(decoder);
 850
 851    //Noop, for shaders it is much faster to flush everything in end_frame
 852 }
 853
 854 static bool
 855 init_pipe_state(struct vl_mpeg12_decoder *dec)
 856 {
 857    struct pipe_depth_stencil_alpha_state dsa;
 858    struct pipe_sampler_state sampler;
 859    unsigned i;
 860
 861    assert(dec);
 862
 863    memset(&dsa, 0, sizeof dsa);
 864    dsa.depth.enabled = 0;
 865    dsa.depth.writemask = 0;
 866    dsa.depth.func = PIPE_FUNC_ALWAYS;
 867    for (i = 0; i < 2; ++i) {
 868       dsa.stencil[i].enabled = 0;
 869       dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
 870       dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
 871       dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
 872       dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
 873       dsa.stencil[i].valuemask = 0;
 874       dsa.stencil[i].writemask = 0;
 875    }
 876    dsa.alpha.enabled = 0;
 877    dsa.alpha.func = PIPE_FUNC_ALWAYS;
 878    dsa.alpha.ref_value = 0;
 879    dec->dsa = dec->context->create_depth_stencil_alpha_state(dec->context, &dsa);
 880    dec->context->bind_depth_stencil_alpha_state(dec->context, dec->dsa);
 881
 882    memset(&sampler, 0, sizeof(sampler));
 883    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 884    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 885    sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
 886    sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 887    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 888    sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 889    sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
 890    sampler.compare_func = PIPE_FUNC_ALWAYS;
 891    sampler.normalized_coords = 1;
 892    dec->sampler_ycbcr = dec->context->create_sampler_state(dec->context, &sampler);
 893    if (!dec->sampler_ycbcr)
 894       return false;
 895
 896    return true;
 897 }
 898
 899 static const struct format_config*
 900 find_format_config(struct vl_mpeg12_decoder *dec, const struct format_config configs[], unsigned num_configs)
 901 {
 902    struct pipe_screen *screen;
 903    unsigned i;
 904
 905    assert(dec);
 906
 907    screen = dec->context->screen;
 908
 909    for (i = 0; i < num_configs; ++i) {
 910       if (!screen->is_format_supported(screen, configs[i].zscan_source_format, PIPE_TEXTURE_2D,
 911                                        1, 1, PIPE_BIND_SAMPLER_VIEW))
 912          continue;
 913
 914       if (configs[i].idct_source_format != PIPE_FORMAT_NONE) {
 915          if (!screen->is_format_supported(screen, configs[i].idct_source_format, PIPE_TEXTURE_2D,
 916                                           1, 1, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET))
 917             continue;
 918
 919          if (!screen->is_format_supported(screen, configs[i].mc_source_format, PIPE_TEXTURE_3D,
 920                                           1, 1, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET))
 921             continue;
 922       } else {
 923          if (!screen->is_format_supported(screen, configs[i].mc_source_format, PIPE_TEXTURE_2D,
 924                                           1, 1, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET))
 925             continue;
 926       }
 927       return &configs[i];
 928    }
 929
 930    return NULL;
 931 }
 932
 933 static bool
 934 init_zscan(struct vl_mpeg12_decoder *dec, const struct format_config* format_config)
 935 {
 936    unsigned num_channels;
 937
 938    assert(dec);
 939
 940    dec->zscan_source_format = format_config->zscan_source_format;
 941    dec->zscan_linear = vl_zscan_layout(dec->context, vl_zscan_linear, dec->blocks_per_line);
 942    dec->zscan_normal = vl_zscan_layout(dec->context, vl_zscan_normal, dec->blocks_per_line);
 943    dec->zscan_alternate = vl_zscan_layout(dec->context, vl_zscan_alternate, dec->blocks_per_line);
 944
 945    num_channels = dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT ? 4 : 1;
 946
 947    if (!vl_zscan_init(&dec->zscan_y, dec->context, dec->base.width, dec->base.height,
 948                       dec->blocks_per_line, dec->num_blocks, num_channels))
 949       return false;
 950
 951    if (!vl_zscan_init(&dec->zscan_c, dec->context, dec->chroma_width, dec->chroma_height,
 952                       dec->blocks_per_line, dec->num_blocks, num_channels))
 953       return false;
 954
 955    return true;
 956 }
 957
 958 static bool
 959 init_idct(struct vl_mpeg12_decoder *dec, const struct format_config* format_config)
 960 {
 961    unsigned nr_of_idct_render_targets, max_inst;
 962    enum pipe_format formats[3];
 963    struct pipe_video_buffer templat;
 964
 965    struct pipe_sampler_view *matrix = NULL;
 966
 967    nr_of_idct_render_targets = dec->context->screen->get_param
 968    (
 969       dec->context->screen, PIPE_CAP_MAX_RENDER_TARGETS
 970    );
 971
 972    max_inst = dec->context->screen->get_shader_param
 973    (
 974       dec->context->screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INSTRUCTIONS
 975    );
 976
 977    // Just assume we need 32 inst per render target, not 100% true, but should work in most cases
 978    if (nr_of_idct_render_targets >= 4 && max_inst >= 32*4)
 979       // more than 4 render targets usually doesn't makes any seens
 980       nr_of_idct_render_targets = 4;
 981    else
 982       nr_of_idct_render_targets = 1;
 983
 984    formats[0] = formats[1] = formats[2] = format_config->idct_source_format;
 985    memset(&templat, 0, sizeof(templat));
 986    templat.width = dec->base.width / 4;
 987    templat.height = dec->base.height;
 988    templat.chroma_format = dec->base.chroma_format;
 989    dec->idct_source = vl_video_buffer_create_ex
 990    (
 991       dec->context, &templat,
 992       formats, 1, 1, PIPE_USAGE_DEFAULT
 993    );
 994
 995    if (!dec->idct_source)
 996       goto error_idct_source;
 997
 998    formats[0] = formats[1] = formats[2] = format_config->mc_source_format;
 999    memset(&templat, 0, sizeof(templat));
1000    templat.width = dec->base.width / nr_of_idct_render_targets;
1001    templat.height = dec->base.height / 4;
1002    templat.chroma_format = dec->base.chroma_format;
1003    dec->mc_source = vl_video_buffer_create_ex
1004    (
1005       dec->context, &templat,
1006       formats, nr_of_idct_render_targets, 1, PIPE_USAGE_DEFAULT
1007    );
1008
1009    if (!dec->mc_source)
1010       goto error_mc_source;
1011
1012    if (!(matrix = vl_idct_upload_matrix(dec->context, format_config->idct_scale)))
1013       goto error_matrix;
1014
1015    if (!vl_idct_init(&dec->idct_y, dec->context, dec->base.width, dec->base.height,
1016                      nr_of_idct_render_targets, matrix, matrix))
1017       goto error_y;
1018
1019    if(!vl_idct_init(&dec->idct_c, dec->context, dec->chroma_width, dec->chroma_height,
1020                     nr_of_idct_render_targets, matrix, matrix))
1021       goto error_c;
1022
1023    pipe_sampler_view_reference(&matrix, NULL);
1024
1025    return true;
1026
1027 error_c:
1028    vl_idct_cleanup(&dec->idct_y);
1029
1030 error_y:
1031    pipe_sampler_view_reference(&matrix, NULL);
1032
1033 error_matrix:
1034    dec->mc_source->destroy(dec->mc_source);
1035
1036 error_mc_source:
1037    dec->idct_source->destroy(dec->idct_source);
1038
1039 error_idct_source:
1040    return false;
1041 }
1042
1043 static bool
1044 init_mc_source_widthout_idct(struct vl_mpeg12_decoder *dec, const struct format_config* format_config)
1045 {
1046    enum pipe_format formats[3];
1047    struct pipe_video_buffer templat;
1048
1049    formats[0] = formats[1] = formats[2] = format_config->mc_source_format;
1050    memset(&templat, 0, sizeof(templat));
1051    templat.width = dec->base.width;
1052    templat.height = dec->base.height;
1053    templat.chroma_format = dec->base.chroma_format;
1054    dec->mc_source = vl_video_buffer_create_ex
1055    (
1056       dec->context, &templat,
1057       formats, 1, 1, PIPE_USAGE_DEFAULT
1058    );
1059
1060    return dec->mc_source != NULL;
1061 }
1062
1063 static void
1064 mc_vert_shader_callback(void *priv, struct vl_mc *mc,
1065                         struct ureg_program *shader,
1066                         unsigned first_output,
1067                         struct ureg_dst tex)
1068 {
1069    struct vl_mpeg12_decoder *dec = priv;
1070    struct ureg_dst o_vtex;
1071
1072    assert(priv && mc);
1073    assert(shader);
1074
1075    if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
1076       struct vl_idct *idct = mc == &dec->mc_y ? &dec->idct_y : &dec->idct_c;
1077       vl_idct_stage2_vert_shader(idct, shader, first_output, tex);
1078    } else {
1079       o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, first_output);
1080       ureg_MOV(shader, ureg_writemask(o_vtex, TGSI_WRITEMASK_XY), ureg_src(tex));
1081    }
1082 }
1083
1084 static void
1085 mc_frag_shader_callback(void *priv, struct vl_mc *mc,
1086                         struct ureg_program *shader,
1087                         unsigned first_input,
1088                         struct ureg_dst dst)
1089 {
1090    struct vl_mpeg12_decoder *dec = priv;
1091    struct ureg_src src, sampler;
1092
1093    assert(priv && mc);
1094    assert(shader);
1095
1096    if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
1097       struct vl_idct *idct = mc == &dec->mc_y ? &dec->idct_y : &dec->idct_c;
1098       vl_idct_stage2_frag_shader(idct, shader, first_input, dst);
1099    } else {
1100       src = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input, TGSI_INTERPOLATE_LINEAR);
1101       sampler = ureg_DECL_sampler(shader, 0);
1102       ureg_TEX(shader, dst, TGSI_TEXTURE_2D, src, sampler);
1103    }
1104 }
1105
1106 struct pipe_video_codec *
1107 vl_create_mpeg12_decoder(struct pipe_context *context,
1108                          const struct pipe_video_codec *templat)
1109 {
1110    const unsigned block_size_pixels = VL_BLOCK_WIDTH * VL_BLOCK_HEIGHT;
1111    const struct format_config *format_config;
1112    struct vl_mpeg12_decoder *dec;
1113
1114    assert(u_reduce_video_profile(templat->profile) == PIPE_VIDEO_FORMAT_MPEG12);
1115
1116    dec = CALLOC_STRUCT(vl_mpeg12_decoder);
1117
1118    if (!dec)
1119       return NULL;
1120
1121    dec->base = *templat;
1122    dec->base.context = context;
1123    dec->context = context->screen->context_create(context->screen, NULL, 0);
1124
1125    dec->base.destroy = vl_mpeg12_destroy;
1126    dec->base.begin_frame = vl_mpeg12_begin_frame;
1127    dec->base.decode_macroblock = vl_mpeg12_decode_macroblock;
1128    dec->base.decode_bitstream = vl_mpeg12_decode_bitstream;
1129    dec->base.end_frame = vl_mpeg12_end_frame;
1130    dec->base.flush = vl_mpeg12_flush;
1131
1132    dec->blocks_per_line = MAX2(util_next_power_of_two(dec->base.width) / block_size_pixels, 4);
1133    dec->num_blocks = (dec->base.width * dec->base.height) / block_size_pixels;
1134    dec->width_in_macroblocks = align(dec->base.width, VL_MACROBLOCK_WIDTH) / VL_MACROBLOCK_WIDTH;
1135
1136    /* TODO: Implement 422, 444 */
1137    assert(dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
1138
1139    if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420) {
1140       dec->chroma_width = dec->base.width / 2;
1141       dec->chroma_height = dec->base.height / 2;
1142       dec->num_blocks = dec->num_blocks * 2;
1143    } else if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_422) {
1144       dec->chroma_width = dec->base.width / 2;
1145       dec->chroma_height = dec->base.height;
1146       dec->num_blocks = dec->num_blocks * 2 + dec->num_blocks;
1147    } else {
1148       dec->chroma_width = dec->base.width;
1149       dec->chroma_height = dec->base.height;
1150       dec->num_blocks = dec->num_blocks * 3;
1151    }
1152
1153    dec->quads = vl_vb_upload_quads(dec->context);
1154    dec->pos = vl_vb_upload_pos(
1155       dec->context,
1156       dec->base.width / VL_MACROBLOCK_WIDTH,
1157       dec->base.height / VL_MACROBLOCK_HEIGHT
1158    );
1159
1160    dec->ves_ycbcr = vl_vb_get_ves_ycbcr(dec->context);
1161    dec->ves_mv = vl_vb_get_ves_mv(dec->context);
1162
1163    switch (templat->entrypoint) {
1164    case PIPE_VIDEO_ENTRYPOINT_BITSTREAM:
1165       format_config = find_format_config(dec, bitstream_format_config, num_bitstream_format_configs);
1166       break;
1167
1168    case PIPE_VIDEO_ENTRYPOINT_IDCT:
1169       format_config = find_format_config(dec, idct_format_config, num_idct_format_configs);
1170       break;
1171
1172    case PIPE_VIDEO_ENTRYPOINT_MC:
1173       format_config = find_format_config(dec, mc_format_config, num_mc_format_configs);
1174       break;
1175
1176    default:
1177       assert(0);
1178       FREE(dec);
1179       return NULL;
1180    }
1181
1182    if (!format_config) {
1183       FREE(dec);
1184       return NULL;
1185    }
1186
1187    if (!init_zscan(dec, format_config))
1188       goto error_zscan;
1189
1190    if (templat->entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
1191       if (!init_idct(dec, format_config))
1192          goto error_sources;
1193    } else {
1194       if (!init_mc_source_widthout_idct(dec, format_config))
1195          goto error_sources;
1196    }
1197
1198    if (!vl_mc_init(&dec->mc_y, dec->context, dec->base.width, dec->base.height,
1199                    VL_MACROBLOCK_HEIGHT, format_config->mc_scale,
1200                    mc_vert_shader_callback, mc_frag_shader_callback, dec))
1201       goto error_mc_y;
1202
1203    // TODO
1204    if (!vl_mc_init(&dec->mc_c, dec->context, dec->base.width, dec->base.height,
1205                    VL_BLOCK_HEIGHT, format_config->mc_scale,
1206                    mc_vert_shader_callback, mc_frag_shader_callback, dec))
1207       goto error_mc_c;
1208
1209    if (!init_pipe_state(dec))
1210       goto error_pipe_state;
1211
1212    list_inithead(&dec->buffer_privates);
1213
1214    return &dec->base;
1215
1216 error_pipe_state:
1217    vl_mc_cleanup(&dec->mc_c);
1218
1219 error_mc_c:
1220    vl_mc_cleanup(&dec->mc_y);
1221
1222 error_mc_y:
1223    if (templat->entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
1224       vl_idct_cleanup(&dec->idct_y);
1225       vl_idct_cleanup(&dec->idct_c);
1226       dec->idct_source->destroy(dec->idct_source);
1227    }
1228    dec->mc_source->destroy(dec->mc_source);
1229
1230 error_sources:
1231    vl_zscan_cleanup(&dec->zscan_y);
1232    vl_zscan_cleanup(&dec->zscan_c);
1233
1234 error_zscan:
1235    FREE(dec);
1236    return NULL;
1237 }