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