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