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