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

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