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