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