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