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