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

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