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