git.sesse.net Git - ffmpeg/blob - libavcodec/vc1dec.c

   1 /*
   2  * VC-1 and WMV3 decoder
   3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
   4  * Copyright (c) 2006-2007 Konstantin Shishkov
   5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
   6  *
   7  * This file is part of Libav.
   8  *
   9  * Libav is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * Libav is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with Libav; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 /**
  25  * @file
  26  * VC-1 and WMV3 decoder
  27  */
  28
  29 #include "avcodec.h"
  30 #include "blockdsp.h"
  31 #include "get_bits.h"
  32 #include "internal.h"
  33 #include "mpeg_er.h"
  34 #include "mpegvideo.h"
  35 #include "msmpeg4data.h"
  36 #include "vc1.h"
  37 #include "vc1data.h"
  38
  39 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
  40
  41 typedef struct SpriteData {
  42     /**
  43      * Transform coefficients for both sprites in 16.16 fixed point format,
  44      * in the order they appear in the bitstream:
  45      *  x scale
  46      *  rotation 1 (unused)
  47      *  x offset
  48      *  rotation 2 (unused)
  49      *  y scale
  50      *  y offset
  51      *  alpha
  52      */
  53     int coefs[2][7];
  54
  55     int effect_type, effect_flag;
  56     int effect_pcount1, effect_pcount2;   ///< amount of effect parameters stored in effect_params
  57     int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
  58 } SpriteData;
  59
  60 static inline int get_fp_val(GetBitContext* gb)
  61 {
  62     return (get_bits_long(gb, 30) - (1 << 29)) << 1;
  63 }
  64
  65 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
  66 {
  67     c[1] = c[3] = 0;
  68
  69     switch (get_bits(gb, 2)) {
  70     case 0:
  71         c[0] = 1 << 16;
  72         c[2] = get_fp_val(gb);
  73         c[4] = 1 << 16;
  74         break;
  75     case 1:
  76         c[0] = c[4] = get_fp_val(gb);
  77         c[2] = get_fp_val(gb);
  78         break;
  79     case 2:
  80         c[0] = get_fp_val(gb);
  81         c[2] = get_fp_val(gb);
  82         c[4] = get_fp_val(gb);
  83         break;
  84     case 3:
  85         c[0] = get_fp_val(gb);
  86         c[1] = get_fp_val(gb);
  87         c[2] = get_fp_val(gb);
  88         c[3] = get_fp_val(gb);
  89         c[4] = get_fp_val(gb);
  90         break;
  91     }
  92     c[5] = get_fp_val(gb);
  93     if (get_bits1(gb))
  94         c[6] = get_fp_val(gb);
  95     else
  96         c[6] = 1 << 16;
  97 }
  98
  99 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
 100 {
 101     AVCodecContext *avctx = v->s.avctx;
 102     int sprite, i;
 103
 104     for (sprite = 0; sprite <= v->two_sprites; sprite++) {
 105         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
 106         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
 107             avpriv_request_sample(avctx, "Non-zero rotation coefficients");
 108         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
 109         for (i = 0; i < 7; i++)
 110             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
 111                    sd->coefs[sprite][i] / (1<<16),
 112                    (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
 113         av_log(avctx, AV_LOG_DEBUG, "\n");
 114     }
 115
 116     skip_bits(gb, 2);
 117     if (sd->effect_type = get_bits_long(gb, 30)) {
 118         switch (sd->effect_pcount1 = get_bits(gb, 4)) {
 119         case 7:
 120             vc1_sprite_parse_transform(gb, sd->effect_params1);
 121             break;
 122         case 14:
 123             vc1_sprite_parse_transform(gb, sd->effect_params1);
 124             vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
 125             break;
 126         default:
 127             for (i = 0; i < sd->effect_pcount1; i++)
 128                 sd->effect_params1[i] = get_fp_val(gb);
 129         }
 130         if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
 131             // effect 13 is simple alpha blending and matches the opacity above
 132             av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
 133             for (i = 0; i < sd->effect_pcount1; i++)
 134                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
 135                        sd->effect_params1[i] / (1 << 16),
 136                        (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
 137             av_log(avctx, AV_LOG_DEBUG, "\n");
 138         }
 139
 140         sd->effect_pcount2 = get_bits(gb, 16);
 141         if (sd->effect_pcount2 > 10) {
 142             av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
 143             return;
 144         } else if (sd->effect_pcount2) {
 145             i = -1;
 146             av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
 147             while (++i < sd->effect_pcount2) {
 148                 sd->effect_params2[i] = get_fp_val(gb);
 149                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
 150                        sd->effect_params2[i] / (1 << 16),
 151                        (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
 152             }
 153             av_log(avctx, AV_LOG_DEBUG, "\n");
 154         }
 155     }
 156     if (sd->effect_flag = get_bits1(gb))
 157         av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
 158
 159     if (get_bits_count(gb) >= gb->size_in_bits +
 160        (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
 161         av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
 162     if (get_bits_count(gb) < gb->size_in_bits - 8)
 163         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
 164 }
 165
 166 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
 167 {
 168     int i, plane, row, sprite;
 169     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
 170     uint8_t* src_h[2][2];
 171     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
 172     int ysub[2];
 173     MpegEncContext *s = &v->s;
 174
 175     for (i = 0; i < 2; i++) {
 176         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
 177         xadv[i] = sd->coefs[i][0];
 178         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
 179             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
 180
 181         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
 182         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
 183     }
 184     alpha = av_clip_uint16(sd->coefs[1][6]);
 185
 186     for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
 187         int width = v->output_width>>!!plane;
 188
 189         for (row = 0; row < v->output_height>>!!plane; row++) {
 190             uint8_t *dst = v->sprite_output_frame->data[plane] +
 191                            v->sprite_output_frame->linesize[plane] * row;
 192
 193             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
 194                 uint8_t *iplane = s->current_picture.f->data[plane];
 195                 int      iline  = s->current_picture.f->linesize[plane];
 196                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
 197                 int      yline  = ycoord >> 16;
 198                 int      next_line;
 199                 ysub[sprite] = ycoord & 0xFFFF;
 200                 if (sprite) {
 201                     iplane = s->last_picture.f->data[plane];
 202                     iline  = s->last_picture.f->linesize[plane];
 203                 }
 204                 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
 205                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
 206                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
 207                     if (ysub[sprite])
 208                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
 209                 } else {
 210                     if (sr_cache[sprite][0] != yline) {
 211                         if (sr_cache[sprite][1] == yline) {
 212                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
 213                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
 214                         } else {
 215                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
 216                             sr_cache[sprite][0] = yline;
 217                         }
 218                     }
 219                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
 220                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
 221                                            iplane + next_line, xoff[sprite],
 222                                            xadv[sprite], width);
 223                         sr_cache[sprite][1] = yline + 1;
 224                     }
 225                     src_h[sprite][0] = v->sr_rows[sprite][0];
 226                     src_h[sprite][1] = v->sr_rows[sprite][1];
 227                 }
 228             }
 229
 230             if (!v->two_sprites) {
 231                 if (ysub[0]) {
 232                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
 233                 } else {
 234                     memcpy(dst, src_h[0][0], width);
 235                 }
 236             } else {
 237                 if (ysub[0] && ysub[1]) {
 238                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
 239                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
 240                 } else if (ysub[0]) {
 241                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
 242                                                        src_h[1][0], alpha, width);
 243                 } else if (ysub[1]) {
 244                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
 245                                                        src_h[0][0], (1<<16)-1-alpha, width);
 246                 } else {
 247                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
 248                 }
 249             }
 250         }
 251
 252         if (!plane) {
 253             for (i = 0; i < 2; i++) {
 254                 xoff[i] >>= 1;
 255                 yoff[i] >>= 1;
 256             }
 257         }
 258
 259     }
 260 }
 261
 262
 263 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
 264 {
 265     MpegEncContext *s     = &v->s;
 266     AVCodecContext *avctx = s->avctx;
 267     SpriteData sd;
 268
 269     vc1_parse_sprites(v, gb, &sd);
 270
 271     if (!s->current_picture.f->data[0]) {
 272         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
 273         return -1;
 274     }
 275
 276     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
 277         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
 278         v->two_sprites = 0;
 279     }
 280
 281     av_frame_unref(v->sprite_output_frame);
 282     if (ff_get_buffer(avctx, v->sprite_output_frame, 0) < 0) {
 283         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 284         return -1;
 285     }
 286
 287     vc1_draw_sprites(v, &sd);
 288
 289     return 0;
 290 }
 291
 292 static void vc1_sprite_flush(AVCodecContext *avctx)
 293 {
 294     VC1Context *v     = avctx->priv_data;
 295     MpegEncContext *s = &v->s;
 296     AVFrame *f = s->current_picture.f;
 297     int plane, i;
 298
 299     /* Windows Media Image codecs have a convergence interval of two keyframes.
 300        Since we can't enforce it, clear to black the missing sprite. This is
 301        wrong but it looks better than doing nothing. */
 302
 303     if (f && f->data[0])
 304         for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
 305             for (i = 0; i < v->sprite_height>>!!plane; i++)
 306                 memset(f->data[plane] + i * f->linesize[plane],
 307                        plane ? 128 : 0, f->linesize[plane]);
 308 }
 309
 310 #endif
 311
 312 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
 313 {
 314     MpegEncContext *s = &v->s;
 315     int i;
 316     int mb_height = FFALIGN(s->mb_height, 2);
 317
 318     /* Allocate mb bitplanes */
 319     v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
 320     v->direct_mb_plane  = av_malloc (s->mb_stride * mb_height);
 321     v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
 322     v->fieldtx_plane    = av_mallocz(s->mb_stride * mb_height);
 323     v->acpred_plane     = av_malloc (s->mb_stride * mb_height);
 324     v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
 325
 326     v->n_allocated_blks = s->mb_width + 2;
 327     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
 328     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
 329     v->cbp              = v->cbp_base + s->mb_stride;
 330     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
 331     v->ttblk            = v->ttblk_base + s->mb_stride;
 332     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
 333     v->is_intra         = v->is_intra_base + s->mb_stride;
 334     v->luma_mv_base     = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
 335     v->luma_mv          = v->luma_mv_base + s->mb_stride;
 336
 337     /* allocate block type info in that way so it could be used with s->block_index[] */
 338     v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
 339     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
 340     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
 341     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (mb_height + 1);
 342
 343     /* allocate memory to store block level MV info */
 344     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
 345     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
 346     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
 347     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
 348     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
 349     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
 350     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
 351     v->mv_f_next[1]     = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
 352
 353     /* Init coded blocks info */
 354     if (v->profile == PROFILE_ADVANCED) {
 355 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
 356 //            return -1;
 357 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
 358 //            return -1;
 359     }
 360
 361     ff_intrax8_common_init(&v->x8,s);
 362
 363     if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 364         for (i = 0; i < 4; i++)
 365             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
 366     }
 367
 368     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
 369         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
 370         !v->mb_type_base) {
 371         av_freep(&v->mv_type_mb_plane);
 372         av_freep(&v->direct_mb_plane);
 373         av_freep(&v->acpred_plane);
 374         av_freep(&v->over_flags_plane);
 375         av_freep(&v->block);
 376         av_freep(&v->cbp_base);
 377         av_freep(&v->ttblk_base);
 378         av_freep(&v->is_intra_base);
 379         av_freep(&v->luma_mv_base);
 380         av_freep(&v->mb_type_base);
 381         return AVERROR(ENOMEM);
 382     }
 383
 384     return 0;
 385 }
 386
 387 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
 388 {
 389     int i;
 390     for (i = 0; i < 64; i++) {
 391 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
 392         v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
 393         v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
 394         v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
 395         v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
 396         v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
 397     }
 398     v->left_blk_sh = 0;
 399     v->top_blk_sh  = 3;
 400 }
 401
 402 /** Initialize a VC1/WMV3 decoder
 403  * @todo TODO: Handle VC-1 IDUs (Transport level?)
 404  * @todo TODO: Decypher remaining bits in extra_data
 405  */
 406 static av_cold int vc1_decode_init(AVCodecContext *avctx)
 407 {
 408     VC1Context *v = avctx->priv_data;
 409     MpegEncContext *s = &v->s;
 410     GetBitContext gb;
 411
 412     /* save the container output size for WMImage */
 413     v->output_width  = avctx->width;
 414     v->output_height = avctx->height;
 415
 416     if (!avctx->extradata_size || !avctx->extradata)
 417         return -1;
 418     if (!(avctx->flags & CODEC_FLAG_GRAY))
 419         avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
 420     else
 421         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 422     v->s.avctx = avctx;
 423
 424     if (ff_vc1_init_common(v) < 0)
 425         return -1;
 426     ff_blockdsp_init(&s->bdsp, avctx);
 427     ff_h264chroma_init(&v->h264chroma, 8);
 428     ff_qpeldsp_init(&s->qdsp);
 429
 430     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
 431         int count = 0;
 432
 433         // looks like WMV3 has a sequence header stored in the extradata
 434         // advanced sequence header may be before the first frame
 435         // the last byte of the extradata is a version number, 1 for the
 436         // samples we can decode
 437
 438         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
 439
 440         if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
 441           return -1;
 442
 443         count = avctx->extradata_size*8 - get_bits_count(&gb);
 444         if (count > 0) {
 445             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
 446                    count, get_bits(&gb, count));
 447         } else if (count < 0) {
 448             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
 449         }
 450     } else { // VC1/WVC1/WVP2
 451         const uint8_t *start = avctx->extradata;
 452         uint8_t *end = avctx->extradata + avctx->extradata_size;
 453         const uint8_t *next;
 454         int size, buf2_size;
 455         uint8_t *buf2 = NULL;
 456         int seq_initialized = 0, ep_initialized = 0;
 457
 458         if (avctx->extradata_size < 16) {
 459             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
 460             return -1;
 461         }
 462
 463         buf2  = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 464         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
 465         next  = start;
 466         for (; next < end; start = next) {
 467             next = find_next_marker(start + 4, end);
 468             size = next - start - 4;
 469             if (size <= 0)
 470                 continue;
 471             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
 472             init_get_bits(&gb, buf2, buf2_size * 8);
 473             switch (AV_RB32(start)) {
 474             case VC1_CODE_SEQHDR:
 475                 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
 476                     av_free(buf2);
 477                     return -1;
 478                 }
 479                 seq_initialized = 1;
 480                 break;
 481             case VC1_CODE_ENTRYPOINT:
 482                 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
 483                     av_free(buf2);
 484                     return -1;
 485                 }
 486                 ep_initialized = 1;
 487                 break;
 488             }
 489         }
 490         av_free(buf2);
 491         if (!seq_initialized || !ep_initialized) {
 492             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
 493             return -1;
 494         }
 495         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
 496     }
 497
 498     v->sprite_output_frame = av_frame_alloc();
 499     if (!v->sprite_output_frame)
 500         return AVERROR(ENOMEM);
 501
 502     avctx->profile = v->profile;
 503     if (v->profile == PROFILE_ADVANCED)
 504         avctx->level = v->level;
 505
 506     avctx->has_b_frames = !!avctx->max_b_frames;
 507
 508     if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
 509         avctx->color_primaries = v->color_prim;
 510     if (v->transfer_char == 1 || v->transfer_char == 7)
 511         avctx->color_trc = v->transfer_char;
 512     if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
 513         avctx->colorspace = v->matrix_coef;
 514
 515     s->mb_width  = (avctx->coded_width  + 15) >> 4;
 516     s->mb_height = (avctx->coded_height + 15) >> 4;
 517
 518     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
 519         ff_vc1_init_transposed_scantables(v);
 520     } else {
 521         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
 522         v->left_blk_sh = 3;
 523         v->top_blk_sh  = 0;
 524     }
 525
 526     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 527         v->sprite_width  = avctx->coded_width;
 528         v->sprite_height = avctx->coded_height;
 529
 530         avctx->coded_width  = avctx->width  = v->output_width;
 531         avctx->coded_height = avctx->height = v->output_height;
 532
 533         // prevent 16.16 overflows
 534         if (v->sprite_width  > 1 << 14 ||
 535             v->sprite_height > 1 << 14 ||
 536             v->output_width  > 1 << 14 ||
 537             v->output_height > 1 << 14) return -1;
 538     }
 539     return 0;
 540 }
 541
 542 /** Close a VC1/WMV3 decoder
 543  * @warning Initial try at using MpegEncContext stuff
 544  */
 545 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
 546 {
 547     VC1Context *v = avctx->priv_data;
 548     int i;
 549
 550     av_frame_free(&v->sprite_output_frame);
 551
 552     for (i = 0; i < 4; i++)
 553         av_freep(&v->sr_rows[i >> 1][i & 1]);
 554     av_freep(&v->hrd_rate);
 555     av_freep(&v->hrd_buffer);
 556     ff_mpv_common_end(&v->s);
 557     av_freep(&v->mv_type_mb_plane);
 558     av_freep(&v->direct_mb_plane);
 559     av_freep(&v->forward_mb_plane);
 560     av_freep(&v->fieldtx_plane);
 561     av_freep(&v->acpred_plane);
 562     av_freep(&v->over_flags_plane);
 563     av_freep(&v->mb_type_base);
 564     av_freep(&v->blk_mv_type_base);
 565     av_freep(&v->mv_f_base);
 566     av_freep(&v->mv_f_next_base);
 567     av_freep(&v->block);
 568     av_freep(&v->cbp_base);
 569     av_freep(&v->ttblk_base);
 570     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
 571     av_freep(&v->luma_mv_base);
 572     ff_intrax8_common_end(&v->x8);
 573     return 0;
 574 }
 575
 576
 577 /** Decode a VC1/WMV3 frame
 578  * @todo TODO: Handle VC-1 IDUs (Transport level?)
 579  */
 580 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
 581                             int *got_frame, AVPacket *avpkt)
 582 {
 583     const uint8_t *buf = avpkt->data;
 584     int buf_size = avpkt->size, n_slices = 0, i, ret;
 585     VC1Context *v = avctx->priv_data;
 586     MpegEncContext *s = &v->s;
 587     AVFrame *pict = data;
 588     uint8_t *buf2 = NULL;
 589     const uint8_t *buf_start = buf;
 590     int mb_height, n_slices1;
 591     struct {
 592         uint8_t *buf;
 593         GetBitContext gb;
 594         int mby_start;
 595     } *slices = NULL, *tmp;
 596
 597     /* no supplementary picture */
 598     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
 599         /* special case for last picture */
 600         if (s->low_delay == 0 && s->next_picture_ptr) {
 601             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
 602                 return ret;
 603             s->next_picture_ptr = NULL;
 604
 605             *got_frame = 1;
 606         }
 607
 608         return 0;
 609     }
 610
 611     //for advanced profile we may need to parse and unescape data
 612     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 613         int buf_size2 = 0;
 614         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 615
 616         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
 617             const uint8_t *start, *end, *next;
 618             int size;
 619
 620             next = buf;
 621             for (start = buf, end = buf + buf_size; next < end; start = next) {
 622                 next = find_next_marker(start + 4, end);
 623                 size = next - start - 4;
 624                 if (size <= 0) continue;
 625                 switch (AV_RB32(start)) {
 626                 case VC1_CODE_FRAME:
 627                     if (avctx->hwaccel)
 628                         buf_start = start;
 629                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
 630                     break;
 631                 case VC1_CODE_FIELD: {
 632                     int buf_size3;
 633                     tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 634                     if (!tmp)
 635                         goto err;
 636                     slices = tmp;
 637                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 638                     if (!slices[n_slices].buf)
 639                         goto err;
 640                     buf_size3 = vc1_unescape_buffer(start + 4, size,
 641                                                     slices[n_slices].buf);
 642                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 643                                   buf_size3 << 3);
 644                     /* assuming that the field marker is at the exact middle,
 645                        hope it's correct */
 646                     slices[n_slices].mby_start = s->mb_height >> 1;
 647                     n_slices1 = n_slices - 1; // index of the last slice of the first field
 648                     n_slices++;
 649                     break;
 650                 }
 651                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
 652                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
 653                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
 654                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
 655                     break;
 656                 case VC1_CODE_SLICE: {
 657                     int buf_size3;
 658                     tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 659                     if (!tmp)
 660                         goto err;
 661                     slices = tmp;
 662                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 663                     if (!slices[n_slices].buf)
 664                         goto err;
 665                     buf_size3 = vc1_unescape_buffer(start + 4, size,
 666                                                     slices[n_slices].buf);
 667                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 668                                   buf_size3 << 3);
 669                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
 670                     n_slices++;
 671                     break;
 672                 }
 673                 }
 674             }
 675         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
 676             const uint8_t *divider;
 677             int buf_size3;
 678
 679             divider = find_next_marker(buf, buf + buf_size);
 680             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
 681                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
 682                 goto err;
 683             } else { // found field marker, unescape second field
 684                 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 685                 if (!tmp)
 686                     goto err;
 687                 slices = tmp;
 688                 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 689                 if (!slices[n_slices].buf)
 690                     goto err;
 691                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
 692                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 693                               buf_size3 << 3);
 694                 slices[n_slices].mby_start = s->mb_height >> 1;
 695                 n_slices1 = n_slices - 1;
 696                 n_slices++;
 697             }
 698             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
 699         } else {
 700             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
 701         }
 702         init_get_bits(&s->gb, buf2, buf_size2*8);
 703     } else
 704         init_get_bits(&s->gb, buf, buf_size*8);
 705
 706     if (v->res_sprite) {
 707         v->new_sprite  = !get_bits1(&s->gb);
 708         v->two_sprites =  get_bits1(&s->gb);
 709         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
 710            we're using the sprite compositor. These are intentionally kept separate
 711            so you can get the raw sprites by using the wmv3 decoder for WMVP or
 712            the vc1 one for WVP2 */
 713         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 714             if (v->new_sprite) {
 715                 // switch AVCodecContext parameters to those of the sprites
 716                 avctx->width  = avctx->coded_width  = v->sprite_width;
 717                 avctx->height = avctx->coded_height = v->sprite_height;
 718             } else {
 719                 goto image;
 720             }
 721         }
 722     }
 723
 724     if (s->context_initialized &&
 725         (s->width  != avctx->coded_width ||
 726          s->height != avctx->coded_height)) {
 727         ff_vc1_decode_end(avctx);
 728     }
 729
 730     if (!s->context_initialized) {
 731         if (ff_msmpeg4_decode_init(avctx) < 0)
 732             goto err;
 733         if (ff_vc1_decode_init_alloc_tables(v) < 0) {
 734             ff_mpv_common_end(s);
 735             goto err;
 736         }
 737
 738         s->low_delay = !avctx->has_b_frames || v->res_sprite;
 739
 740         if (v->profile == PROFILE_ADVANCED) {
 741             s->h_edge_pos = avctx->coded_width;
 742             s->v_edge_pos = avctx->coded_height;
 743         }
 744     }
 745
 746     // do parse frame header
 747     v->pic_header_flag = 0;
 748     v->first_pic_header_flag = 1;
 749     if (v->profile < PROFILE_ADVANCED) {
 750         if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
 751             goto err;
 752         }
 753     } else {
 754         if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 755             goto err;
 756         }
 757     }
 758     v->first_pic_header_flag = 0;
 759
 760     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
 761         && s->pict_type != AV_PICTURE_TYPE_I) {
 762         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
 763         goto err;
 764     }
 765
 766     // for skipping the frame
 767     s->current_picture.f->pict_type = s->pict_type;
 768     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
 769
 770     /* skip B-frames if we don't have reference frames */
 771     if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
 772         goto end;
 773     }
 774     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
 775         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
 776          avctx->skip_frame >= AVDISCARD_ALL) {
 777         goto end;
 778     }
 779
 780     if (s->next_p_frame_damaged) {
 781         if (s->pict_type == AV_PICTURE_TYPE_B)
 782             goto end;
 783         else
 784             s->next_p_frame_damaged = 0;
 785     }
 786
 787     if (ff_mpv_frame_start(s, avctx) < 0) {
 788         goto err;
 789     }
 790
 791     // process pulldown flags
 792     s->current_picture_ptr->f->repeat_pict = 0;
 793     // Pulldown flags are only valid when 'broadcast' has been set.
 794     // So ticks_per_frame will be 2
 795     if (v->rff) {
 796         // repeat field
 797         s->current_picture_ptr->f->repeat_pict = 1;
 798     } else if (v->rptfrm) {
 799         // repeat frames
 800         s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
 801     }
 802
 803     s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
 804     s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
 805
 806     if (avctx->hwaccel) {
 807         if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
 808             goto err;
 809         if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
 810             goto err;
 811         if (avctx->hwaccel->end_frame(avctx) < 0)
 812             goto err;
 813     } else {
 814         int header_ret = 0;
 815
 816         ff_mpeg_er_frame_start(s);
 817
 818         v->bits = buf_size * 8;
 819         v->end_mb_x = s->mb_width;
 820         if (v->field_mode) {
 821             s->current_picture.f->linesize[0] <<= 1;
 822             s->current_picture.f->linesize[1] <<= 1;
 823             s->current_picture.f->linesize[2] <<= 1;
 824             s->linesize                      <<= 1;
 825             s->uvlinesize                    <<= 1;
 826         }
 827         mb_height = s->mb_height >> v->field_mode;
 828
 829         if (!mb_height) {
 830             av_log(v->s.avctx, AV_LOG_ERROR, "Invalid mb_height.\n");
 831             goto err;
 832         }
 833
 834         for (i = 0; i <= n_slices; i++) {
 835             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
 836                 if (v->field_mode <= 0) {
 837                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
 838                            "picture boundary (%d >= %d)\n", i,
 839                            slices[i - 1].mby_start, mb_height);
 840                     continue;
 841                 }
 842                 v->second_field = 1;
 843                 v->blocks_off   = s->mb_width  * s->mb_height << 1;
 844                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
 845             } else {
 846                 v->second_field = 0;
 847                 v->blocks_off   = 0;
 848                 v->mb_off       = 0;
 849             }
 850             if (i) {
 851                 v->pic_header_flag = 0;
 852                 if (v->field_mode && i == n_slices1 + 2) {
 853                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
 854                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
 855                         if (avctx->err_recognition & AV_EF_EXPLODE)
 856                             goto err;
 857                         continue;
 858                     }
 859                 } else if (get_bits1(&s->gb)) {
 860                     v->pic_header_flag = 1;
 861                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
 862                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
 863                         if (avctx->err_recognition & AV_EF_EXPLODE)
 864                             goto err;
 865                         continue;
 866                     }
 867                 }
 868             }
 869             if (header_ret < 0)
 870                 continue;
 871             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
 872             if (!v->field_mode || v->second_field)
 873                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
 874             else
 875                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
 876             ff_vc1_decode_blocks(v);
 877             if (i != n_slices)
 878                 s->gb = slices[i].gb;
 879         }
 880         if (v->field_mode) {
 881             v->second_field = 0;
 882             s->current_picture.f->linesize[0] >>= 1;
 883             s->current_picture.f->linesize[1] >>= 1;
 884             s->current_picture.f->linesize[2] >>= 1;
 885             s->linesize                      >>= 1;
 886             s->uvlinesize                    >>= 1;
 887             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
 888                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
 889                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
 890             }
 891         }
 892         ff_dlog(s->avctx, "Consumed %i/%i bits\n",
 893                 get_bits_count(&s->gb), s->gb.size_in_bits);
 894 //  if (get_bits_count(&s->gb) > buf_size * 8)
 895 //      return -1;
 896         if (!v->field_mode)
 897             ff_er_frame_end(&s->er);
 898     }
 899
 900     ff_mpv_frame_end(s);
 901
 902     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 903 image:
 904         avctx->width  = avctx->coded_width  = v->output_width;
 905         avctx->height = avctx->coded_height = v->output_height;
 906         if (avctx->skip_frame >= AVDISCARD_NONREF)
 907             goto end;
 908 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
 909         if (vc1_decode_sprites(v, &s->gb))
 910             goto err;
 911 #endif
 912         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
 913             goto err;
 914         *got_frame = 1;
 915     } else {
 916         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 917             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
 918                 goto err;
 919             ff_print_debug_info(s, s->current_picture_ptr);
 920             *got_frame = 1;
 921         } else if (s->last_picture_ptr) {
 922             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
 923                 goto err;
 924             ff_print_debug_info(s, s->last_picture_ptr);
 925             *got_frame = 1;
 926         }
 927     }
 928
 929 end:
 930     av_free(buf2);
 931     for (i = 0; i < n_slices; i++)
 932         av_free(slices[i].buf);
 933     av_free(slices);
 934     return buf_size;
 935
 936 err:
 937     av_free(buf2);
 938     for (i = 0; i < n_slices; i++)
 939         av_free(slices[i].buf);
 940     av_free(slices);
 941     return -1;
 942 }
 943
 944
 945 static const AVProfile profiles[] = {
 946     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
 947     { FF_PROFILE_VC1_MAIN,     "Main"     },
 948     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
 949     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
 950     { FF_PROFILE_UNKNOWN },
 951 };
 952
 953 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
 954 #if CONFIG_VC1_DXVA2_HWACCEL
 955     AV_PIX_FMT_DXVA2_VLD,
 956 #endif
 957 #if CONFIG_VC1_VAAPI_HWACCEL
 958     AV_PIX_FMT_VAAPI_VLD,
 959 #endif
 960 #if CONFIG_VC1_VDPAU_HWACCEL
 961     AV_PIX_FMT_VDPAU,
 962 #endif
 963     AV_PIX_FMT_YUV420P,
 964     AV_PIX_FMT_NONE
 965 };
 966
 967 AVCodec ff_vc1_decoder = {
 968     .name           = "vc1",
 969     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
 970     .type           = AVMEDIA_TYPE_VIDEO,
 971     .id             = AV_CODEC_ID_VC1,
 972     .priv_data_size = sizeof(VC1Context),
 973     .init           = vc1_decode_init,
 974     .close          = ff_vc1_decode_end,
 975     .decode         = vc1_decode_frame,
 976     .flush          = ff_mpeg_flush,
 977     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 978     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
 979     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
 980 };
 981
 982 #if CONFIG_WMV3_DECODER
 983 AVCodec ff_wmv3_decoder = {
 984     .name           = "wmv3",
 985     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
 986     .type           = AVMEDIA_TYPE_VIDEO,
 987     .id             = AV_CODEC_ID_WMV3,
 988     .priv_data_size = sizeof(VC1Context),
 989     .init           = vc1_decode_init,
 990     .close          = ff_vc1_decode_end,
 991     .decode         = vc1_decode_frame,
 992     .flush          = ff_mpeg_flush,
 993     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 994     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
 995     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
 996 };
 997 #endif
 998
 999 #if CONFIG_WMV3IMAGE_DECODER
1000 AVCodec ff_wmv3image_decoder = {
1001     .name           = "wmv3image",
1002     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1003     .type           = AVMEDIA_TYPE_VIDEO,
1004     .id             = AV_CODEC_ID_WMV3IMAGE,
1005     .priv_data_size = sizeof(VC1Context),
1006     .init           = vc1_decode_init,
1007     .close          = ff_vc1_decode_end,
1008     .decode         = vc1_decode_frame,
1009     .capabilities   = CODEC_CAP_DR1,
1010     .flush          = vc1_sprite_flush,
1011     .pix_fmts       = (const enum AVPixelFormat[]) {
1012         AV_PIX_FMT_YUV420P,
1013         AV_PIX_FMT_NONE
1014     },
1015 };
1016 #endif
1017
1018 #if CONFIG_VC1IMAGE_DECODER
1019 AVCodec ff_vc1image_decoder = {
1020     .name           = "vc1image",
1021     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1022     .type           = AVMEDIA_TYPE_VIDEO,
1023     .id             = AV_CODEC_ID_VC1IMAGE,
1024     .priv_data_size = sizeof(VC1Context),
1025     .init           = vc1_decode_init,
1026     .close          = ff_vc1_decode_end,
1027     .decode         = vc1_decode_frame,
1028     .capabilities   = CODEC_CAP_DR1,
1029     .flush          = vc1_sprite_flush,
1030     .pix_fmts       = (const enum AVPixelFormat[]) {
1031         AV_PIX_FMT_YUV420P,
1032         AV_PIX_FMT_NONE
1033     },
1034 };
1035 #endif