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