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

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