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

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