vc1dec: Properly call deinit function on error
[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;
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