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