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