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 "hwaccel.h"
  33 #include "internal.h"
  34 #include "mpeg_er.h"
  35 #include "mpegvideo.h"
  36 #include "msmpeg4.h"
  37 #include "msmpeg4data.h"
  38 #include "profiles.h"
  39 #include "vc1.h"
  40 #include "vc1data.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]) * 3 * s->mb_stride);
 344     if (!v->block || !v->cbp_base)
 345         goto error;
 346     v->cbp              = v->cbp_base + 2 * s->mb_stride;
 347     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
 348     if (!v->ttblk_base)
 349         goto error;
 350     v->ttblk            = v->ttblk_base + 2 * s->mb_stride;
 351     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
 352     if (!v->is_intra_base)
 353         goto error;
 354     v->is_intra         = v->is_intra_base + 2 * s->mb_stride;
 355     v->luma_mv_base     = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
 356     if (!v->luma_mv_base)
 357         goto error;
 358     v->luma_mv          = v->luma_mv_base + 2 * 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,
 391                                  s->block, s->block_last_index,
 392                                  s->mb_width, s->mb_height);
 393     if (ret < 0)
 394         goto error;
 395
 396     return 0;
 397
 398 error:
 399     ff_vc1_decode_end(s->avctx);
 400     return ret;
 401 }
 402
 403 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
 404 {
 405     int i;
 406     for (i = 0; i < 64; i++) {
 407 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
 408         v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
 409         v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
 410         v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
 411         v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
 412         v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
 413     }
 414     v->left_blk_sh = 0;
 415     v->top_blk_sh  = 3;
 416 }
 417
 418 /** Initialize a VC1/WMV3 decoder
 419  * @todo TODO: Handle VC-1 IDUs (Transport level?)
 420  * @todo TODO: Decipher remaining bits in extra_data
 421  */
 422 static av_cold int vc1_decode_init(AVCodecContext *avctx)
 423 {
 424     VC1Context *v = avctx->priv_data;
 425     MpegEncContext *s = &v->s;
 426     GetBitContext gb;
 427     int ret;
 428
 429     /* save the container output size for WMImage */
 430     v->output_width  = avctx->width;
 431     v->output_height = avctx->height;
 432
 433     if (!avctx->extradata_size || !avctx->extradata)
 434         return -1;
 435     v->s.avctx = avctx;
 436
 437     if ((ret = ff_vc1_init_common(v)) < 0)
 438         return ret;
 439
 440     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
 441         int count = 0;
 442
 443         // looks like WMV3 has a sequence header stored in the extradata
 444         // advanced sequence header may be before the first frame
 445         // the last byte of the extradata is a version number, 1 for the
 446         // samples we can decode
 447
 448         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
 449
 450         if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
 451           return ret;
 452
 453         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
 454             avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
 455             return AVERROR_PATCHWELCOME;
 456         }
 457
 458         count = avctx->extradata_size*8 - get_bits_count(&gb);
 459         if (count > 0) {
 460             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
 461                    count, get_bits_long(&gb, FFMIN(count, 32)));
 462         } else if (count < 0) {
 463             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
 464         }
 465     } else { // VC1/WVC1/WVP2
 466         const uint8_t *start = avctx->extradata;
 467         uint8_t *end = avctx->extradata + avctx->extradata_size;
 468         const uint8_t *next;
 469         int size, buf2_size;
 470         uint8_t *buf2 = NULL;
 471         int seq_initialized = 0, ep_initialized = 0;
 472
 473         if (avctx->extradata_size < 16) {
 474             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
 475             return -1;
 476         }
 477
 478         buf2  = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
 479         if (!buf2)
 480             return AVERROR(ENOMEM);
 481
 482         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
 483         next  = start;
 484         for (; next < end; start = next) {
 485             next = find_next_marker(start + 4, end);
 486             size = next - start - 4;
 487             if (size <= 0)
 488                 continue;
 489             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
 490             init_get_bits(&gb, buf2, buf2_size * 8);
 491             switch (AV_RB32(start)) {
 492             case VC1_CODE_SEQHDR:
 493                 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
 494                     av_free(buf2);
 495                     return ret;
 496                 }
 497                 seq_initialized = 1;
 498                 break;
 499             case VC1_CODE_ENTRYPOINT:
 500                 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
 501                     av_free(buf2);
 502                     return ret;
 503                 }
 504                 ep_initialized = 1;
 505                 break;
 506             }
 507         }
 508         av_free(buf2);
 509         if (!seq_initialized || !ep_initialized) {
 510             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
 511             return -1;
 512         }
 513         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
 514     }
 515
 516     avctx->profile = v->profile;
 517     if (v->profile == PROFILE_ADVANCED)
 518         avctx->level = v->level;
 519
 520     if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
 521         avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
 522     else {
 523         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 524         if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
 525             avctx->color_range = AVCOL_RANGE_MPEG;
 526     }
 527
 528     // ensure static VLC tables are initialized
 529     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
 530         return ret;
 531     if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
 532         return ret;
 533     // Hack to ensure the above functions will be called
 534     // again once we know all necessary settings.
 535     // That this is necessary might indicate a bug.
 536     ff_vc1_decode_end(avctx);
 537
 538     ff_blockdsp_init(&s->bdsp, avctx);
 539     ff_h264chroma_init(&v->h264chroma, 8);
 540     ff_qpeldsp_init(&s->qdsp);
 541
 542     // Must happen after calling ff_vc1_decode_end
 543     // to avoid de-allocating the sprite_output_frame
 544     v->sprite_output_frame = av_frame_alloc();
 545     if (!v->sprite_output_frame)
 546         return AVERROR(ENOMEM);
 547
 548     avctx->has_b_frames = !!avctx->max_b_frames;
 549
 550     if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
 551         avctx->color_primaries = v->color_prim;
 552     if (v->transfer_char == 1 || v->transfer_char == 7)
 553         avctx->color_trc = v->transfer_char;
 554     if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
 555         avctx->colorspace = v->matrix_coef;
 556
 557     s->mb_width  = (avctx->coded_width  + 15) >> 4;
 558     s->mb_height = (avctx->coded_height + 15) >> 4;
 559
 560     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
 561         ff_vc1_init_transposed_scantables(v);
 562     } else {
 563         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
 564         v->left_blk_sh = 3;
 565         v->top_blk_sh  = 0;
 566     }
 567
 568     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 569         v->sprite_width  = avctx->coded_width;
 570         v->sprite_height = avctx->coded_height;
 571
 572         avctx->coded_width  = avctx->width  = v->output_width;
 573         avctx->coded_height = avctx->height = v->output_height;
 574
 575         // prevent 16.16 overflows
 576         if (v->sprite_width  > 1 << 14 ||
 577             v->sprite_height > 1 << 14 ||
 578             v->output_width  > 1 << 14 ||
 579             v->output_height > 1 << 14) return -1;
 580
 581         if ((v->sprite_width&1) || (v->sprite_height&1)) {
 582             avpriv_request_sample(avctx, "odd sprites support");
 583             return AVERROR_PATCHWELCOME;
 584         }
 585     }
 586     return 0;
 587 }
 588
 589 /** Close a VC1/WMV3 decoder
 590  * @warning Initial try at using MpegEncContext stuff
 591  */
 592 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
 593 {
 594     VC1Context *v = avctx->priv_data;
 595     int i;
 596
 597     av_frame_free(&v->sprite_output_frame);
 598
 599     for (i = 0; i < 4; i++)
 600         av_freep(&v->sr_rows[i >> 1][i & 1]);
 601     av_freep(&v->hrd_rate);
 602     av_freep(&v->hrd_buffer);
 603     ff_mpv_common_end(&v->s);
 604     av_freep(&v->mv_type_mb_plane);
 605     av_freep(&v->direct_mb_plane);
 606     av_freep(&v->forward_mb_plane);
 607     av_freep(&v->fieldtx_plane);
 608     av_freep(&v->acpred_plane);
 609     av_freep(&v->over_flags_plane);
 610     av_freep(&v->mb_type_base);
 611     av_freep(&v->blk_mv_type_base);
 612     av_freep(&v->mv_f_base);
 613     av_freep(&v->mv_f_next_base);
 614     av_freep(&v->block);
 615     av_freep(&v->cbp_base);
 616     av_freep(&v->ttblk_base);
 617     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
 618     av_freep(&v->luma_mv_base);
 619     ff_intrax8_common_end(&v->x8);
 620     return 0;
 621 }
 622
 623
 624 /** Decode a VC1/WMV3 frame
 625  * @todo TODO: Handle VC-1 IDUs (Transport level?)
 626  */
 627 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
 628                             int *got_frame, AVPacket *avpkt)
 629 {
 630     const uint8_t *buf = avpkt->data;
 631     int buf_size = avpkt->size, n_slices = 0, i, ret;
 632     VC1Context *v = avctx->priv_data;
 633     MpegEncContext *s = &v->s;
 634     AVFrame *pict = data;
 635     uint8_t *buf2 = NULL;
 636     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
 637     int mb_height, n_slices1=-1;
 638     struct {
 639         uint8_t *buf;
 640         GetBitContext gb;
 641         int mby_start;
 642         const uint8_t *rawbuf;
 643         int raw_size;
 644     } *slices = NULL, *tmp;
 645
 646     v->second_field = 0;
 647
 648     if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
 649         s->low_delay = 1;
 650
 651     /* no supplementary picture */
 652     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
 653         /* special case for last picture */
 654         if (s->low_delay == 0 && s->next_picture_ptr) {
 655             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
 656                 return ret;
 657             s->next_picture_ptr = NULL;
 658
 659             *got_frame = 1;
 660         }
 661
 662         return buf_size;
 663     }
 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                         buf_start = start;
 685                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
 686                     break;
 687                 case VC1_CODE_FIELD: {
 688                     int buf_size3;
 689                     if (avctx->hwaccel)
 690                         buf_start_second_field = start;
 691                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
 692                     if (!tmp) {
 693                         ret = AVERROR(ENOMEM);
 694                         goto err;
 695                     }
 696                     slices = tmp;
 697                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
 698                     if (!slices[n_slices].buf) {
 699                         ret = AVERROR(ENOMEM);
 700                         goto err;
 701                     }
 702                     buf_size3 = vc1_unescape_buffer(start + 4, size,
 703                                                     slices[n_slices].buf);
 704                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 705                                   buf_size3 << 3);
 706                     slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
 707                     slices[n_slices].rawbuf = start;
 708                     slices[n_slices].raw_size = size + 4;
 709                     n_slices1 = n_slices - 1; // index of the last slice of the first field
 710                     n_slices++;
 711                     break;
 712                 }
 713                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
 714                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
 715                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
 716                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
 717                     break;
 718                 case VC1_CODE_SLICE: {
 719                     int buf_size3;
 720                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
 721                     if (!tmp) {
 722                         ret = AVERROR(ENOMEM);
 723                         goto err;
 724                     }
 725                     slices = tmp;
 726                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
 727                     if (!slices[n_slices].buf) {
 728                         ret = AVERROR(ENOMEM);
 729                         goto err;
 730                     }
 731                     buf_size3 = vc1_unescape_buffer(start + 4, size,
 732                                                     slices[n_slices].buf);
 733                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 734                                   buf_size3 << 3);
 735                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
 736                     slices[n_slices].rawbuf = start;
 737                     slices[n_slices].raw_size = size + 4;
 738                     n_slices++;
 739                     break;
 740                 }
 741                 }
 742             }
 743         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
 744             const uint8_t *divider;
 745             int buf_size3;
 746
 747             divider = find_next_marker(buf, buf + buf_size);
 748             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
 749                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
 750                 ret = AVERROR_INVALIDDATA;
 751                 goto err;
 752             } else { // found field marker, unescape second field
 753                 if (avctx->hwaccel)
 754                     buf_start_second_field = divider;
 755                 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
 756                 if (!tmp) {
 757                     ret = AVERROR(ENOMEM);
 758                     goto err;
 759                 }
 760                 slices = tmp;
 761                 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
 762                 if (!slices[n_slices].buf) {
 763                     ret = AVERROR(ENOMEM);
 764                     goto err;
 765                 }
 766                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
 767                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
 768                               buf_size3 << 3);
 769                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
 770                 slices[n_slices].rawbuf = divider;
 771                 slices[n_slices].raw_size = buf + buf_size - divider;
 772                 n_slices1 = n_slices - 1;
 773                 n_slices++;
 774             }
 775             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
 776         } else {
 777             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
 778         }
 779         init_get_bits(&s->gb, buf2, buf_size2*8);
 780     } else
 781         init_get_bits(&s->gb, buf, buf_size*8);
 782
 783     if (v->res_sprite) {
 784         v->new_sprite  = !get_bits1(&s->gb);
 785         v->two_sprites =  get_bits1(&s->gb);
 786         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
 787            we're using the sprite compositor. These are intentionally kept separate
 788            so you can get the raw sprites by using the wmv3 decoder for WMVP or
 789            the vc1 one for WVP2 */
 790         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
 791             if (v->new_sprite) {
 792                 // switch AVCodecContext parameters to those of the sprites
 793                 avctx->width  = avctx->coded_width  = v->sprite_width;
 794                 avctx->height = avctx->coded_height = v->sprite_height;
 795             } else {
 796                 goto image;
 797             }
 798         }
 799     }
 800
 801     if (s->context_initialized &&
 802         (s->width  != avctx->coded_width ||
 803          s->height != avctx->coded_height)) {
 804         ff_vc1_decode_end(avctx);
 805     }
 806
 807     if (!s->context_initialized) {
 808         if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
 809             goto err;
 810         if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
 811             ff_mpv_common_end(s);
 812             goto err;
 813         }
 814
 815         s->low_delay = !avctx->has_b_frames || v->res_sprite;
 816
 817         if (v->profile == PROFILE_ADVANCED) {
 818             if(avctx->coded_width<=1 || avctx->coded_height<=1) {
 819                 ret = AVERROR_INVALIDDATA;
 820                 goto err;
 821             }
 822             s->h_edge_pos = avctx->coded_width;
 823             s->v_edge_pos = avctx->coded_height;
 824         }
 825     }
 826
 827     // do parse frame header
 828     v->pic_header_flag = 0;
 829     v->first_pic_header_flag = 1;
 830     if (v->profile < PROFILE_ADVANCED) {
 831         if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
 832             goto err;
 833         }
 834     } else {
 835         if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
 836             goto err;
 837         }
 838     }
 839     v->first_pic_header_flag = 0;
 840
 841     if (avctx->debug & FF_DEBUG_PICT_INFO)
 842         av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
 843
 844     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
 845         && s->pict_type != AV_PICTURE_TYPE_I) {
 846         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
 847         ret = AVERROR_INVALIDDATA;
 848         goto err;
 849     }
 850
 851     if ((s->mb_height >> v->field_mode) == 0) {
 852         av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
 853         ret = AVERROR_INVALIDDATA;
 854         goto err;
 855     }
 856
 857     // for skipping the frame
 858     s->current_picture.f->pict_type = s->pict_type;
 859     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
 860
 861     /* skip B-frames if we don't have reference frames */
 862     if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
 863         av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
 864         goto end;
 865     }
 866     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
 867         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
 868          avctx->skip_frame >= AVDISCARD_ALL) {
 869         goto end;
 870     }
 871
 872     if (s->next_p_frame_damaged) {
 873         if (s->pict_type == AV_PICTURE_TYPE_B)
 874             goto end;
 875         else
 876             s->next_p_frame_damaged = 0;
 877     }
 878
 879     if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
 880         goto err;
 881     }
 882
 883     v->s.current_picture_ptr->field_picture = v->field_mode;
 884     v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
 885     v->s.current_picture_ptr->f->top_field_first  = v->tff;
 886
 887     // process pulldown flags
 888     s->current_picture_ptr->f->repeat_pict = 0;
 889     // Pulldown flags are only valid when 'broadcast' has been set.
 890     // So ticks_per_frame will be 2
 891     if (v->rff) {
 892         // repeat field
 893         s->current_picture_ptr->f->repeat_pict = 1;
 894     } else if (v->rptfrm) {
 895         // repeat frames
 896         s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
 897     }
 898
 899     s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
 900     s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
 901
 902     if (avctx->hwaccel) {
 903         s->mb_y = 0;
 904         if (v->field_mode && buf_start_second_field) {
 905             // decode first field
 906             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
 907             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
 908                 goto err;
 909
 910             if (n_slices1 == -1) {
 911                 // no slices, decode the field as-is
 912                 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
 913                     goto err;
 914             } else {
 915                 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
 916                     goto err;
 917
 918                 for (i = 0 ; i < n_slices1 + 1; i++) {
 919                     s->gb = slices[i].gb;
 920                     s->mb_y = slices[i].mby_start;
 921
 922                     v->pic_header_flag = get_bits1(&s->gb);
 923                     if (v->pic_header_flag) {
 924                         if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 925                             av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
 926                             ret = AVERROR_INVALIDDATA;
 927                             if (avctx->err_recognition & AV_EF_EXPLODE)
 928                                 goto err;
 929                             continue;
 930                         }
 931                     }
 932
 933                     if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
 934                         goto err;
 935                 }
 936             }
 937
 938             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
 939                 goto err;
 940
 941             // decode second field
 942             s->gb = slices[n_slices1 + 1].gb;
 943             s->mb_y = slices[n_slices1 + 1].mby_start;
 944             s->picture_structure = PICT_TOP_FIELD + v->tff;
 945             v->second_field = 1;
 946             v->pic_header_flag = 0;
 947             if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 948                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
 949                 ret = AVERROR_INVALIDDATA;
 950                 goto err;
 951             }
 952             v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
 953
 954             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
 955                 goto err;
 956
 957             if (n_slices - n_slices1 == 2) {
 958                 // no slices, decode the field as-is
 959                 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
 960                     goto err;
 961             } else {
 962                 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
 963                     goto err;
 964
 965                 for (i = n_slices1 + 2; i < n_slices; i++) {
 966                     s->gb = slices[i].gb;
 967                     s->mb_y = slices[i].mby_start;
 968
 969                     v->pic_header_flag = get_bits1(&s->gb);
 970                     if (v->pic_header_flag) {
 971                         if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 972                             av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
 973                             ret = AVERROR_INVALIDDATA;
 974                             if (avctx->err_recognition & AV_EF_EXPLODE)
 975                                 goto err;
 976                             continue;
 977                         }
 978                     }
 979
 980                     if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
 981                         goto err;
 982                 }
 983             }
 984
 985             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
 986                 goto err;
 987         } else {
 988             s->picture_structure = PICT_FRAME;
 989             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
 990                 goto err;
 991
 992             if (n_slices == 0) {
 993                 // no slices, decode the frame as-is
 994                 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
 995                     goto err;
 996             } else {
 997                 // decode the frame part as the first slice
 998                 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
 999                     goto err;
1000
1001                 // and process the slices as additional slices afterwards
1002                 for (i = 0 ; i < n_slices; i++) {
1003                     s->gb = slices[i].gb;
1004                     s->mb_y = slices[i].mby_start;
1005
1006                     v->pic_header_flag = get_bits1(&s->gb);
1007                     if (v->pic_header_flag) {
1008                         if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1009                             av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1010                             ret = AVERROR_INVALIDDATA;
1011                             if (avctx->err_recognition & AV_EF_EXPLODE)
1012                                 goto err;
1013                             continue;
1014                         }
1015                     }
1016
1017                     if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1018                         goto err;
1019                 }
1020             }
1021             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1022                 goto err;
1023         }
1024     } else {
1025         int header_ret = 0;
1026
1027         ff_mpeg_er_frame_start(s);
1028
1029         v->bits = buf_size * 8;
1030         v->end_mb_x = s->mb_width;
1031         if (v->field_mode) {
1032             s->current_picture.f->linesize[0] <<= 1;
1033             s->current_picture.f->linesize[1] <<= 1;
1034             s->current_picture.f->linesize[2] <<= 1;
1035             s->linesize                      <<= 1;
1036             s->uvlinesize                    <<= 1;
1037         }
1038         mb_height = s->mb_height >> v->field_mode;
1039
1040         av_assert0 (mb_height > 0);
1041
1042         for (i = 0; i <= n_slices; i++) {
1043             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
1044                 if (v->field_mode <= 0) {
1045                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1046                            "picture boundary (%d >= %d)\n", i,
1047                            slices[i - 1].mby_start, mb_height);
1048                     continue;
1049                 }
1050                 v->second_field = 1;
1051                 av_assert0((s->mb_height & 1) == 0);
1052                 v->blocks_off   = s->b8_stride * (s->mb_height&~1);
1053                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
1054             } else {
1055                 v->second_field = 0;
1056                 v->blocks_off   = 0;
1057                 v->mb_off       = 0;
1058             }
1059             if (i) {
1060                 v->pic_header_flag = 0;
1061                 if (v->field_mode && i == n_slices1 + 2) {
1062                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1063                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1064                         ret = AVERROR_INVALIDDATA;
1065                         if (avctx->err_recognition & AV_EF_EXPLODE)
1066                             goto err;
1067                         continue;
1068                     }
1069                 } else if (get_bits1(&s->gb)) {
1070                     v->pic_header_flag = 1;
1071                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1072                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1073                         ret = AVERROR_INVALIDDATA;
1074                         if (avctx->err_recognition & AV_EF_EXPLODE)
1075                             goto err;
1076                         continue;
1077                     }
1078                 }
1079             }
1080             if (header_ret < 0)
1081                 continue;
1082             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1083             if (!v->field_mode || v->second_field)
1084                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1085             else {
1086                 if (i >= n_slices) {
1087                     av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1088                     continue;
1089                 }
1090                 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1091             }
1092             if (s->end_mb_y <= s->start_mb_y) {
1093                 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1094                 continue;
1095             }
1096             if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1097                  (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1098                 !v->cbpcy_vlc) {
1099                 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1100                 continue;
1101             }
1102             ff_vc1_decode_blocks(v);
1103             if (i != n_slices)
1104                 s->gb = slices[i].gb;
1105         }
1106         if (v->field_mode) {
1107             v->second_field = 0;
1108             s->current_picture.f->linesize[0] >>= 1;
1109             s->current_picture.f->linesize[1] >>= 1;
1110             s->current_picture.f->linesize[2] >>= 1;
1111             s->linesize                      >>= 1;
1112             s->uvlinesize                    >>= 1;
1113             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1114                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1115                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1116             }
1117         }
1118         ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1119                 get_bits_count(&s->gb), s->gb.size_in_bits);
1120 //  if (get_bits_count(&s->gb) > buf_size * 8)
1121 //      return -1;
1122         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1123             ret = AVERROR_INVALIDDATA;
1124             goto err;
1125         }
1126         if (!v->field_mode)
1127             ff_er_frame_end(&s->er);
1128     }
1129
1130     ff_mpv_frame_end(s);
1131
1132     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1133 image:
1134         avctx->width  = avctx->coded_width  = v->output_width;
1135         avctx->height = avctx->coded_height = v->output_height;
1136         if (avctx->skip_frame >= AVDISCARD_NONREF)
1137             goto end;
1138 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1139         if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1140             goto err;
1141 #endif
1142         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1143             goto err;
1144         *got_frame = 1;
1145     } else {
1146         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1147             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1148                 goto err;
1149             ff_print_debug_info(s, s->current_picture_ptr, pict);
1150             *got_frame = 1;
1151         } else if (s->last_picture_ptr) {
1152             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1153                 goto err;
1154             ff_print_debug_info(s, s->last_picture_ptr, pict);
1155             *got_frame = 1;
1156         }
1157     }
1158
1159 end:
1160     av_free(buf2);
1161     for (i = 0; i < n_slices; i++)
1162         av_free(slices[i].buf);
1163     av_free(slices);
1164     return buf_size;
1165
1166 err:
1167     av_free(buf2);
1168     for (i = 0; i < n_slices; i++)
1169         av_free(slices[i].buf);
1170     av_free(slices);
1171     return ret;
1172 }
1173
1174
1175 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1176 #if CONFIG_VC1_DXVA2_HWACCEL
1177     AV_PIX_FMT_DXVA2_VLD,
1178 #endif
1179 #if CONFIG_VC1_D3D11VA_HWACCEL
1180     AV_PIX_FMT_D3D11VA_VLD,
1181     AV_PIX_FMT_D3D11,
1182 #endif
1183 #if CONFIG_VC1_NVDEC_HWACCEL
1184     AV_PIX_FMT_CUDA,
1185 #endif
1186 #if CONFIG_VC1_VAAPI_HWACCEL
1187     AV_PIX_FMT_VAAPI,
1188 #endif
1189 #if CONFIG_VC1_VDPAU_HWACCEL
1190     AV_PIX_FMT_VDPAU,
1191 #endif
1192     AV_PIX_FMT_YUV420P,
1193     AV_PIX_FMT_NONE
1194 };
1195
1196 AVCodec ff_vc1_decoder = {
1197     .name           = "vc1",
1198     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1199     .type           = AVMEDIA_TYPE_VIDEO,
1200     .id             = AV_CODEC_ID_VC1,
1201     .priv_data_size = sizeof(VC1Context),
1202     .init           = vc1_decode_init,
1203     .close          = ff_vc1_decode_end,
1204     .decode         = vc1_decode_frame,
1205     .flush          = ff_mpeg_flush,
1206     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1207     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1208     .hw_configs     = (const AVCodecHWConfigInternal*[]) {
1209 #if CONFIG_VC1_DXVA2_HWACCEL
1210                         HWACCEL_DXVA2(vc1),
1211 #endif
1212 #if CONFIG_VC1_D3D11VA_HWACCEL
1213                         HWACCEL_D3D11VA(vc1),
1214 #endif
1215 #if CONFIG_VC1_D3D11VA2_HWACCEL
1216                         HWACCEL_D3D11VA2(vc1),
1217 #endif
1218 #if CONFIG_VC1_NVDEC_HWACCEL
1219                         HWACCEL_NVDEC(vc1),
1220 #endif
1221 #if CONFIG_VC1_VAAPI_HWACCEL
1222                         HWACCEL_VAAPI(vc1),
1223 #endif
1224 #if CONFIG_VC1_VDPAU_HWACCEL
1225                         HWACCEL_VDPAU(vc1),
1226 #endif
1227                         NULL
1228                     },
1229     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1230 };
1231
1232 #if CONFIG_WMV3_DECODER
1233 AVCodec ff_wmv3_decoder = {
1234     .name           = "wmv3",
1235     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1236     .type           = AVMEDIA_TYPE_VIDEO,
1237     .id             = AV_CODEC_ID_WMV3,
1238     .priv_data_size = sizeof(VC1Context),
1239     .init           = vc1_decode_init,
1240     .close          = ff_vc1_decode_end,
1241     .decode         = vc1_decode_frame,
1242     .flush          = ff_mpeg_flush,
1243     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1244     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1245     .hw_configs     = (const AVCodecHWConfigInternal*[]) {
1246 #if CONFIG_WMV3_DXVA2_HWACCEL
1247                         HWACCEL_DXVA2(wmv3),
1248 #endif
1249 #if CONFIG_WMV3_D3D11VA_HWACCEL
1250                         HWACCEL_D3D11VA(wmv3),
1251 #endif
1252 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1253                         HWACCEL_D3D11VA2(wmv3),
1254 #endif
1255 #if CONFIG_WMV3_NVDEC_HWACCEL
1256                         HWACCEL_NVDEC(wmv3),
1257 #endif
1258 #if CONFIG_WMV3_VAAPI_HWACCEL
1259                         HWACCEL_VAAPI(wmv3),
1260 #endif
1261 #if CONFIG_WMV3_VDPAU_HWACCEL
1262                         HWACCEL_VDPAU(wmv3),
1263 #endif
1264                         NULL
1265                     },
1266     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1267 };
1268 #endif
1269
1270 #if CONFIG_WMV3IMAGE_DECODER
1271 AVCodec ff_wmv3image_decoder = {
1272     .name           = "wmv3image",
1273     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1274     .type           = AVMEDIA_TYPE_VIDEO,
1275     .id             = AV_CODEC_ID_WMV3IMAGE,
1276     .priv_data_size = sizeof(VC1Context),
1277     .init           = vc1_decode_init,
1278     .close          = ff_vc1_decode_end,
1279     .decode         = vc1_decode_frame,
1280     .capabilities   = AV_CODEC_CAP_DR1,
1281     .flush          = vc1_sprite_flush,
1282     .pix_fmts       = (const enum AVPixelFormat[]) {
1283         AV_PIX_FMT_YUV420P,
1284         AV_PIX_FMT_NONE
1285     },
1286 };
1287 #endif
1288
1289 #if CONFIG_VC1IMAGE_DECODER
1290 AVCodec ff_vc1image_decoder = {
1291     .name           = "vc1image",
1292     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1293     .type           = AVMEDIA_TYPE_VIDEO,
1294     .id             = AV_CODEC_ID_VC1IMAGE,
1295     .priv_data_size = sizeof(VC1Context),
1296     .init           = vc1_decode_init,
1297     .close          = ff_vc1_decode_end,
1298     .decode         = vc1_decode_frame,
1299     .capabilities   = AV_CODEC_CAP_DR1,
1300     .flush          = vc1_sprite_flush,
1301     .pix_fmts       = (const enum AVPixelFormat[]) {
1302         AV_PIX_FMT_YUV420P,
1303         AV_PIX_FMT_NONE
1304     },
1305 };
1306 #endif