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 {
  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(sd->coefs[1][6], 0, (1<<16) - 1);
 192
 193     for (plane = 0; plane < (s->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 < (s->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 (!(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     v->s.avctx = avctx;
 435
 436     if ((ret = ff_vc1_init_common(v)) < 0)
 437         return ret;
 438     // ensure static VLC tables are initialized
 439     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
 440         return ret;
 441     if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
 442         return ret;
 443     // Hack to ensure the above functions will be called
 444     // again once we know all necessary settings.
 445     // That this is necessary might indicate a bug.
 446     ff_vc1_decode_end(avctx);
 447
 448     ff_blockdsp_init(&s->bdsp, avctx);
 449     ff_h264chroma_init(&v->h264chroma, 8);
 450     ff_qpeldsp_init(&s->qdsp);
 451
 452     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
 453         int count = 0;
 454
 455         // looks like WMV3 has a sequence header stored in the extradata
 456         // advanced sequence header may be before the first frame
 457         // the last byte of the extradata is a version number, 1 for the
 458         // samples we can decode
 459
 460         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
 461
 462         if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
 463           return ret;
 464
 465         count = avctx->extradata_size*8 - get_bits_count(&gb);
 466         if (count > 0) {
 467             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
 468                    count, get_bits(&gb, count));
 469         } else if (count < 0) {
 470             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
 471         }
 472     } else { // VC1/WVC1/WVP2
 473         const uint8_t *start = avctx->extradata;
 474         uint8_t *end = avctx->extradata + avctx->extradata_size;
 475         const uint8_t *next;
 476         int size, buf2_size;
 477         uint8_t *buf2 = NULL;
 478         int seq_initialized = 0, ep_initialized = 0;
 479
 480         if (avctx->extradata_size < 16) {
 481             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
 482             return -1;
 483         }
 484
 485         buf2  = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 486         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
 487         next  = start;
 488         for (; next < end; start = next) {
 489             next = find_next_marker(start + 4, end);
 490             size = next - start - 4;
 491             if (size <= 0)
 492                 continue;
 493             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
 494             init_get_bits(&gb, buf2, buf2_size * 8);
 495             switch (AV_RB32(start)) {
 496             case VC1_CODE_SEQHDR:
 497                 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
 498                     av_free(buf2);
 499                     return ret;
 500                 }
 501                 seq_initialized = 1;
 502                 break;
 503             case VC1_CODE_ENTRYPOINT:
 504                 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
 505                     av_free(buf2);
 506                     return ret;
 507                 }
 508                 ep_initialized = 1;
 509                 break;
 510             }
 511         }
 512         av_free(buf2);
 513         if (!seq_initialized || !ep_initialized) {
 514             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
 515             return -1;
 516         }
 517         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
 518     }
 519
 520     v->sprite_output_frame = av_frame_alloc();
 521     if (!v->sprite_output_frame)
 522         return AVERROR(ENOMEM);
 523
 524     avctx->profile = v->profile;
 525     if (v->profile == PROFILE_ADVANCED)
 526         avctx->level = v->level;
 527
 528     avctx->has_b_frames = !!avctx->max_b_frames;
 529
 530     if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
 531         avctx->color_primaries = v->color_prim;
 532     if (v->transfer_char == 1 || v->transfer_char == 7)
 533         avctx->color_trc = v->transfer_char;
 534     if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
 535         avctx->colorspace = v->matrix_coef;
 536
 537     s->mb_width  = (avctx->coded_width  + 15) >> 4;
 538     s->mb_height = (avctx->coded_height + 15) >> 4;
 539
 540     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
 541         ff_vc1_init_transposed_scantables(v);
 542     } else {
 543         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
 544         v->left_blk_sh = 3;
 545         v->top_blk_sh  = 0;
 546     }
 547
 548     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 549         v->sprite_width  = avctx->coded_width;
 550         v->sprite_height = avctx->coded_height;
 551
 552         avctx->coded_width  = avctx->width  = v->output_width;
 553         avctx->coded_height = avctx->height = v->output_height;
 554
 555         // prevent 16.16 overflows
 556         if (v->sprite_width  > 1 << 14 ||
 557             v->sprite_height > 1 << 14 ||
 558             v->output_width  > 1 << 14 ||
 559             v->output_height > 1 << 14) return -1;
 560
 561         if ((v->sprite_width&1) || (v->sprite_height&1)) {
 562             avpriv_request_sample(avctx, "odd sprites support");
 563             return AVERROR_PATCHWELCOME;
 564         }
 565     }
 566     return 0;
 567 }
 568
 569 /** Close a VC1/WMV3 decoder
 570  * @warning Initial try at using MpegEncContext stuff
 571  */
 572 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
 573 {
 574     VC1Context *v = avctx->priv_data;
 575     int i;
 576
 577     av_frame_free(&v->sprite_output_frame);
 578
 579     for (i = 0; i < 4; i++)
 580         av_freep(&v->sr_rows[i >> 1][i & 1]);
 581     av_freep(&v->hrd_rate);
 582     av_freep(&v->hrd_buffer);
 583     ff_mpv_common_end(&v->s);
 584     av_freep(&v->mv_type_mb_plane);
 585     av_freep(&v->direct_mb_plane);
 586     av_freep(&v->forward_mb_plane);
 587     av_freep(&v->fieldtx_plane);
 588     av_freep(&v->acpred_plane);
 589     av_freep(&v->over_flags_plane);
 590     av_freep(&v->mb_type_base);
 591     av_freep(&v->blk_mv_type_base);
 592     av_freep(&v->mv_f_base);
 593     av_freep(&v->mv_f_next_base);
 594     av_freep(&v->block);
 595     av_freep(&v->cbp_base);
 596     av_freep(&v->ttblk_base);
 597     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
 598     av_freep(&v->luma_mv_base);
 599     ff_intrax8_common_end(&v->x8);
 600     return 0;
 601 }
 602
 603
 604 /** Decode a VC1/WMV3 frame
 605  * @todo TODO: Handle VC-1 IDUs (Transport level?)
 606  */
 607 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
 608                             int *got_frame, AVPacket *avpkt)
 609 {
 610     const uint8_t *buf = avpkt->data;
 611     int buf_size = avpkt->size, n_slices = 0, i, ret;
 612     VC1Context *v = avctx->priv_data;
 613     MpegEncContext *s = &v->s;
 614     AVFrame *pict = data;
 615     uint8_t *buf2 = NULL;
 616     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
 617     int mb_height, n_slices1=-1;
 618     struct {
 619         uint8_t *buf;
 620         GetBitContext gb;
 621         int mby_start;
 622     } *slices = NULL, *tmp;
 623
 624     v->second_field = 0;
 625
 626     if(s->flags & CODEC_FLAG_LOW_DELAY)
 627         s->low_delay = 1;
 628
 629     /* no supplementary picture */
 630     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
 631         /* special case for last picture */
 632         if (s->low_delay == 0 && s->next_picture_ptr) {
 633             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
 634                 return ret;
 635             s->next_picture_ptr = NULL;
 636
 637             *got_frame = 1;
 638         }
 639
 640         return buf_size;
 641     }
 642
 643     if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
 644         if (v->profile < PROFILE_ADVANCED)
 645             avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
 646         else
 647             avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
 648     }
 649
 650     //for advanced profile we may need to parse and unescape data
 651     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 652         int buf_size2 = 0;
 653         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 654         if (!buf2)
 655             return AVERROR(ENOMEM);
 656
 657         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
 658             const uint8_t *start, *end, *next;
 659             int size;
 660
 661             next = buf;
 662             for (start = buf, end = buf + buf_size; next < end; start = next) {
 663                 next = find_next_marker(start + 4, end);
 664                 size = next - start - 4;
 665                 if (size <= 0) continue;
 666                 switch (AV_RB32(start)) {
 667                 case VC1_CODE_FRAME:
 668                     if (avctx->hwaccel ||
 669                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
 670                         buf_start = start;
 671                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
 672                     break;
 673                 case VC1_CODE_FIELD: {
 674                     int buf_size3;
 675                     if (avctx->hwaccel ||
 676                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
 677                         buf_start_second_field = start;
 678                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
 679                     if (!tmp)
 680                         goto err;
 681                     slices = tmp;
 682                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 683                     if (!slices[n_slices].buf)
 684                         goto err;
 685                     buf_size3 = vc1_unescape_buffer(start + 4, size,
 686                                                     slices[n_slices].buf);
 687                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 688                                   buf_size3 << 3);
 689                     /* assuming that the field marker is at the exact middle,
 690                        hope it's correct */
 691                     slices[n_slices].mby_start = s->mb_height + 1 >> 1;
 692                     n_slices1 = n_slices - 1; // index of the last slice of the first field
 693                     n_slices++;
 694                     break;
 695                 }
 696                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
 697                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
 698                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
 699                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
 700                     break;
 701                 case VC1_CODE_SLICE: {
 702                     int buf_size3;
 703                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
 704                     if (!tmp)
 705                         goto err;
 706                     slices = tmp;
 707                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 708                     if (!slices[n_slices].buf)
 709                         goto err;
 710                     buf_size3 = vc1_unescape_buffer(start + 4, size,
 711                                                     slices[n_slices].buf);
 712                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 713                                   buf_size3 << 3);
 714                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
 715                     n_slices++;
 716                     break;
 717                 }
 718                 }
 719             }
 720         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
 721             const uint8_t *divider;
 722             int buf_size3;
 723
 724             divider = find_next_marker(buf, buf + buf_size);
 725             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
 726                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
 727                 goto err;
 728             } else { // found field marker, unescape second field
 729                 if (avctx->hwaccel ||
 730                     s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
 731                     buf_start_second_field = divider;
 732                 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
 733                 if (!tmp)
 734                     goto err;
 735                 slices = tmp;
 736                 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 737                 if (!slices[n_slices].buf)
 738                     goto err;
 739                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
 740                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 741                               buf_size3 << 3);
 742                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
 743                 n_slices1 = n_slices - 1;
 744                 n_slices++;
 745             }
 746             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
 747         } else {
 748             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
 749         }
 750         init_get_bits(&s->gb, buf2, buf_size2*8);
 751     } else
 752         init_get_bits(&s->gb, buf, buf_size*8);
 753
 754     if (v->res_sprite) {
 755         v->new_sprite  = !get_bits1(&s->gb);
 756         v->two_sprites =  get_bits1(&s->gb);
 757         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
 758            we're using the sprite compositor. These are intentionally kept separate
 759            so you can get the raw sprites by using the wmv3 decoder for WMVP or
 760            the vc1 one for WVP2 */
 761         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 762             if (v->new_sprite) {
 763                 // switch AVCodecContext parameters to those of the sprites
 764                 avctx->width  = avctx->coded_width  = v->sprite_width;
 765                 avctx->height = avctx->coded_height = v->sprite_height;
 766             } else {
 767                 goto image;
 768             }
 769         }
 770     }
 771
 772     if (s->context_initialized &&
 773         (s->width  != avctx->coded_width ||
 774          s->height != avctx->coded_height)) {
 775         ff_vc1_decode_end(avctx);
 776     }
 777
 778     if (!s->context_initialized) {
 779         if (ff_msmpeg4_decode_init(avctx) < 0)
 780             goto err;
 781         if (ff_vc1_decode_init_alloc_tables(v) < 0) {
 782             ff_mpv_common_end(s);
 783             goto err;
 784         }
 785
 786         s->low_delay = !avctx->has_b_frames || v->res_sprite;
 787
 788         if (v->profile == PROFILE_ADVANCED) {
 789             if(avctx->coded_width<=1 || avctx->coded_height<=1)
 790                 goto err;
 791             s->h_edge_pos = avctx->coded_width;
 792             s->v_edge_pos = avctx->coded_height;
 793         }
 794     }
 795
 796     // do parse frame header
 797     v->pic_header_flag = 0;
 798     v->first_pic_header_flag = 1;
 799     if (v->profile < PROFILE_ADVANCED) {
 800         if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
 801             goto err;
 802         }
 803     } else {
 804         if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 805             goto err;
 806         }
 807     }
 808     v->first_pic_header_flag = 0;
 809
 810     if (avctx->debug & FF_DEBUG_PICT_INFO)
 811         av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
 812
 813     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
 814         && s->pict_type != AV_PICTURE_TYPE_I) {
 815         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
 816         goto err;
 817     }
 818
 819     if ((s->mb_height >> v->field_mode) == 0) {
 820         av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
 821         goto err;
 822     }
 823
 824     // for skipping the frame
 825     s->current_picture.f->pict_type = s->pict_type;
 826     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
 827
 828     /* skip B-frames if we don't have reference frames */
 829     if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
 830         av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
 831         goto end;
 832     }
 833     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
 834         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
 835          avctx->skip_frame >= AVDISCARD_ALL) {
 836         goto end;
 837     }
 838
 839     if (s->next_p_frame_damaged) {
 840         if (s->pict_type == AV_PICTURE_TYPE_B)
 841             goto end;
 842         else
 843             s->next_p_frame_damaged = 0;
 844     }
 845
 846     if (ff_mpv_frame_start(s, avctx) < 0) {
 847         goto err;
 848     }
 849
 850     v->s.current_picture_ptr->field_picture = v->field_mode;
 851     v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
 852     v->s.current_picture_ptr->f->top_field_first  = v->tff;
 853
 854     // process pulldown flags
 855     s->current_picture_ptr->f->repeat_pict = 0;
 856     // Pulldown flags are only valid when 'broadcast' has been set.
 857     // So ticks_per_frame will be 2
 858     if (v->rff) {
 859         // repeat field
 860         s->current_picture_ptr->f->repeat_pict = 1;
 861     } else if (v->rptfrm) {
 862         // repeat frames
 863         s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
 864     }
 865
 866     s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
 867     s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
 868
 869     if ((CONFIG_VC1_VDPAU_DECODER)
 870         &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
 871         if (v->field_mode && buf_start_second_field) {
 872             ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
 873             ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
 874         } else {
 875             ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
 876         }
 877     } else if (avctx->hwaccel) {
 878         if (v->field_mode && buf_start_second_field) {
 879             // decode first field
 880             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
 881             if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
 882                 goto err;
 883             if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
 884                 goto err;
 885             if (avctx->hwaccel->end_frame(avctx) < 0)
 886                 goto err;
 887
 888             // decode second field
 889             s->gb = slices[n_slices1 + 1].gb;
 890             s->picture_structure = PICT_TOP_FIELD + v->tff;
 891             v->second_field = 1;
 892             v->pic_header_flag = 0;
 893             if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 894                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
 895                 goto err;
 896             }
 897             v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
 898
 899             if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
 900                 goto err;
 901             if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
 902                 goto err;
 903             if (avctx->hwaccel->end_frame(avctx) < 0)
 904                 goto err;
 905         } else {
 906             s->picture_structure = PICT_FRAME;
 907             if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
 908                 goto err;
 909             if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
 910                 goto err;
 911             if (avctx->hwaccel->end_frame(avctx) < 0)
 912                 goto err;
 913         }
 914     } else {
 915         int header_ret = 0;
 916
 917         ff_mpeg_er_frame_start(s);
 918
 919         v->bits = buf_size * 8;
 920         v->end_mb_x = s->mb_width;
 921         if (v->field_mode) {
 922             s->current_picture.f->linesize[0] <<= 1;
 923             s->current_picture.f->linesize[1] <<= 1;
 924             s->current_picture.f->linesize[2] <<= 1;
 925             s->linesize                      <<= 1;
 926             s->uvlinesize                    <<= 1;
 927         }
 928         mb_height = s->mb_height >> v->field_mode;
 929
 930         av_assert0 (mb_height > 0);
 931
 932         for (i = 0; i <= n_slices; i++) {
 933             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
 934                 if (v->field_mode <= 0) {
 935                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
 936                            "picture boundary (%d >= %d)\n", i,
 937                            slices[i - 1].mby_start, mb_height);
 938                     continue;
 939                 }
 940                 v->second_field = 1;
 941                 av_assert0((s->mb_height & 1) == 0);
 942                 v->blocks_off   = s->b8_stride * (s->mb_height&~1);
 943                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
 944             } else {
 945                 v->second_field = 0;
 946                 v->blocks_off   = 0;
 947                 v->mb_off       = 0;
 948             }
 949             if (i) {
 950                 v->pic_header_flag = 0;
 951                 if (v->field_mode && i == n_slices1 + 2) {
 952                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
 953                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
 954                         if (avctx->err_recognition & AV_EF_EXPLODE)
 955                             goto err;
 956                         continue;
 957                     }
 958                 } else if (get_bits1(&s->gb)) {
 959                     v->pic_header_flag = 1;
 960                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
 961                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
 962                         if (avctx->err_recognition & AV_EF_EXPLODE)
 963                             goto err;
 964                         continue;
 965                     }
 966                 }
 967             }
 968             if (header_ret < 0)
 969                 continue;
 970             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
 971             if (!v->field_mode || v->second_field)
 972                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
 973             else {
 974                 if (i >= n_slices) {
 975                     av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
 976                     continue;
 977                 }
 978                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
 979             }
 980             if (s->end_mb_y <= s->start_mb_y) {
 981                 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
 982                 continue;
 983             }
 984             if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
 985                 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
 986                 continue;
 987             }
 988             ff_vc1_decode_blocks(v);
 989             if (i != n_slices)
 990                 s->gb = slices[i].gb;
 991         }
 992         if (v->field_mode) {
 993             v->second_field = 0;
 994             s->current_picture.f->linesize[0] >>= 1;
 995             s->current_picture.f->linesize[1] >>= 1;
 996             s->current_picture.f->linesize[2] >>= 1;
 997             s->linesize                      >>= 1;
 998             s->uvlinesize                    >>= 1;
 999             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1000                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1001                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1002             }
1003         }
1004         av_dlog(s->avctx, "Consumed %i/%i bits\n",
1005                 get_bits_count(&s->gb), s->gb.size_in_bits);
1006 //  if (get_bits_count(&s->gb) > buf_size * 8)
1007 //      return -1;
1008         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
1009             goto err;
1010         if (!v->field_mode)
1011             ff_er_frame_end(&s->er);
1012     }
1013
1014     ff_mpv_frame_end(s);
1015
1016     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1017 image:
1018         avctx->width  = avctx->coded_width  = v->output_width;
1019         avctx->height = avctx->coded_height = v->output_height;
1020         if (avctx->skip_frame >= AVDISCARD_NONREF)
1021             goto end;
1022 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1023         if (vc1_decode_sprites(v, &s->gb))
1024             goto err;
1025 #endif
1026         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1027             goto err;
1028         *got_frame = 1;
1029     } else {
1030         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1031             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1032                 goto err;
1033             ff_print_debug_info(s, s->current_picture_ptr, pict);
1034             *got_frame = 1;
1035         } else if (s->last_picture_ptr) {
1036             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1037                 goto err;
1038             ff_print_debug_info(s, s->last_picture_ptr, pict);
1039             *got_frame = 1;
1040         }
1041     }
1042
1043 end:
1044     av_free(buf2);
1045     for (i = 0; i < n_slices; i++)
1046         av_free(slices[i].buf);
1047     av_free(slices);
1048     return buf_size;
1049
1050 err:
1051     av_free(buf2);
1052     for (i = 0; i < n_slices; i++)
1053         av_free(slices[i].buf);
1054     av_free(slices);
1055     return -1;
1056 }
1057
1058
1059 static const AVProfile profiles[] = {
1060     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
1061     { FF_PROFILE_VC1_MAIN,     "Main"     },
1062     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
1063     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
1064     { FF_PROFILE_UNKNOWN },
1065 };
1066
1067 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1068 #if CONFIG_VC1_DXVA2_HWACCEL
1069     AV_PIX_FMT_DXVA2_VLD,
1070 #endif
1071 #if CONFIG_VC1_VAAPI_HWACCEL
1072     AV_PIX_FMT_VAAPI_VLD,
1073 #endif
1074 #if CONFIG_VC1_VDPAU_HWACCEL
1075     AV_PIX_FMT_VDPAU,
1076 #endif
1077     AV_PIX_FMT_YUV420P,
1078     AV_PIX_FMT_NONE
1079 };
1080
1081 AVCodec ff_vc1_decoder = {
1082     .name           = "vc1",
1083     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1084     .type           = AVMEDIA_TYPE_VIDEO,
1085     .id             = AV_CODEC_ID_VC1,
1086     .priv_data_size = sizeof(VC1Context),
1087     .init           = vc1_decode_init,
1088     .close          = ff_vc1_decode_end,
1089     .decode         = vc1_decode_frame,
1090     .flush          = ff_mpeg_flush,
1091     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1092     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1093     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
1094 };
1095
1096 #if CONFIG_WMV3_DECODER
1097 AVCodec ff_wmv3_decoder = {
1098     .name           = "wmv3",
1099     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1100     .type           = AVMEDIA_TYPE_VIDEO,
1101     .id             = AV_CODEC_ID_WMV3,
1102     .priv_data_size = sizeof(VC1Context),
1103     .init           = vc1_decode_init,
1104     .close          = ff_vc1_decode_end,
1105     .decode         = vc1_decode_frame,
1106     .flush          = ff_mpeg_flush,
1107     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1108     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1109     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
1110 };
1111 #endif
1112
1113 #if CONFIG_WMV3_VDPAU_DECODER
1114 AVCodec ff_wmv3_vdpau_decoder = {
1115     .name           = "wmv3_vdpau",
1116     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1117     .type           = AVMEDIA_TYPE_VIDEO,
1118     .id             = AV_CODEC_ID_WMV3,
1119     .priv_data_size = sizeof(VC1Context),
1120     .init           = vc1_decode_init,
1121     .close          = ff_vc1_decode_end,
1122     .decode         = vc1_decode_frame,
1123     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
1124     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1125     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
1126 };
1127 #endif
1128
1129 #if CONFIG_VC1_VDPAU_DECODER
1130 AVCodec ff_vc1_vdpau_decoder = {
1131     .name           = "vc1_vdpau",
1132     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1133     .type           = AVMEDIA_TYPE_VIDEO,
1134     .id             = AV_CODEC_ID_VC1,
1135     .priv_data_size = sizeof(VC1Context),
1136     .init           = vc1_decode_init,
1137     .close          = ff_vc1_decode_end,
1138     .decode         = vc1_decode_frame,
1139     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
1140     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1141     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
1142 };
1143 #endif
1144
1145 #if CONFIG_WMV3IMAGE_DECODER
1146 AVCodec ff_wmv3image_decoder = {
1147     .name           = "wmv3image",
1148     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1149     .type           = AVMEDIA_TYPE_VIDEO,
1150     .id             = AV_CODEC_ID_WMV3IMAGE,
1151     .priv_data_size = sizeof(VC1Context),
1152     .init           = vc1_decode_init,
1153     .close          = ff_vc1_decode_end,
1154     .decode         = vc1_decode_frame,
1155     .capabilities   = CODEC_CAP_DR1,
1156     .flush          = vc1_sprite_flush,
1157     .pix_fmts       = (const enum AVPixelFormat[]) {
1158         AV_PIX_FMT_YUV420P,
1159         AV_PIX_FMT_NONE
1160     },
1161 };
1162 #endif
1163
1164 #if CONFIG_VC1IMAGE_DECODER
1165 AVCodec ff_vc1image_decoder = {
1166     .name           = "vc1image",
1167     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1168     .type           = AVMEDIA_TYPE_VIDEO,
1169     .id             = AV_CODEC_ID_VC1IMAGE,
1170     .priv_data_size = sizeof(VC1Context),
1171     .init           = vc1_decode_init,
1172     .close          = ff_vc1_decode_end,
1173     .decode         = vc1_decode_frame,
1174     .capabilities   = CODEC_CAP_DR1,
1175     .flush          = vc1_sprite_flush,
1176     .pix_fmts       = (const enum AVPixelFormat[]) {
1177         AV_PIX_FMT_YUV420P,
1178         AV_PIX_FMT_NONE
1179     },
1180 };
1181 #endif