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