intrax8: Keep a reference to the context idctdsp
[libav.git] / libavcodec / vc1dec.c
CommitLineData
b761659b
DB
1/*
2 * VC-1 and WMV3 decoder
cad16562 3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
b761659b
DB
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6 *
2912e87a 7 * This file is part of Libav.
b761659b 8 *
2912e87a 9 * Libav is free software; you can redistribute it and/or
b761659b
DB
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 *
2912e87a 14 * Libav is distributed in the hope that it will be useful,
b761659b
DB
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
2912e87a 20 * License along with Libav; if not, write to the Free Software
b761659b
DB
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24/**
ba87f080 25 * @file
b761659b 26 * VC-1 and WMV3 decoder
b761659b 27 */
50f97219 28
b761659b 29#include "avcodec.h"
04d14c9b
LB
30#include "blockdsp.h"
31#include "get_bits.h"
32#include "internal.h"
7b9ef8d7 33#include "mpeg_er.h"
b761659b 34#include "mpegvideo.h"
31a117a0 35#include "msmpeg4.h"
04d14c9b 36#include "msmpeg4data.h"
2c681139 37#include "profiles.h"
b761659b
DB
38#include "vc1.h"
39#include "vc1data.h"
b761659b 40
45ecda85
AD
41#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
42
7f9f771e 43typedef struct SpriteData {
45ecda85
AD
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
62static inline int get_fp_val(GetBitContext* gb)
768c5251 63{
50f97219 64 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
768c5251
AD
65}
66
45ecda85 67static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
768c5251 68{
45ecda85 69 c[1] = c[3] = 0;
768c5251
AD
70
71 switch (get_bits(gb, 2)) {
72 case 0:
50f97219 73 c[0] = 1 << 16;
45ecda85 74 c[2] = get_fp_val(gb);
50f97219 75 c[4] = 1 << 16;
768c5251
AD
76 break;
77 case 1:
45ecda85
AD
78 c[0] = c[4] = get_fp_val(gb);
79 c[2] = get_fp_val(gb);
768c5251
AD
80 break;
81 case 2:
45ecda85
AD
82 c[0] = get_fp_val(gb);
83 c[2] = get_fp_val(gb);
84 c[4] = get_fp_val(gb);
768c5251
AD
85 break;
86 case 3:
45ecda85
AD
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);
768c5251
AD
92 break;
93 }
45ecda85 94 c[5] = get_fp_val(gb);
768c5251 95 if (get_bits1(gb))
45ecda85 96 c[6] = get_fp_val(gb);
768c5251 97 else
50f97219 98 c[6] = 1 << 16;
768c5251
AD
99}
100
45ecda85 101static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
768c5251 102{
45ecda85
AD
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])
6d97484d 109 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
45ecda85 110 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
768c5251 111 for (i = 0; i < 7; i++)
45ecda85
AD
112 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
113 sd->coefs[sprite][i] / (1<<16),
50f97219 114 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
45ecda85 115 av_log(avctx, AV_LOG_DEBUG, "\n");
768c5251 116 }
45ecda85 117
768c5251 118 skip_bits(gb, 2);
45ecda85
AD
119 if (sd->effect_type = get_bits_long(gb, 30)) {
120 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
768c5251 121 case 7:
45ecda85 122 vc1_sprite_parse_transform(gb, sd->effect_params1);
768c5251
AD
123 break;
124 case 14:
45ecda85
AD
125 vc1_sprite_parse_transform(gb, sd->effect_params1);
126 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
768c5251
AD
127 break;
128 default:
45ecda85
AD
129 for (i = 0; i < sd->effect_pcount1; i++)
130 sd->effect_params1[i] = get_fp_val(gb);
768c5251 131 }
45ecda85 132 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
768c5251 133 // effect 13 is simple alpha blending and matches the opacity above
45ecda85
AD
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",
50f97219
KS
137 sd->effect_params1[i] / (1 << 16),
138 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
45ecda85 139 av_log(avctx, AV_LOG_DEBUG, "\n");
768c5251
AD
140 }
141
45ecda85
AD
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");
768c5251 145 return;
45ecda85
AD
146 } else if (sd->effect_pcount2) {
147 i = -1;
148 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
50f97219 149 while (++i < sd->effect_pcount2) {
45ecda85
AD
150 sd->effect_params2[i] = get_fp_val(gb);
151 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
50f97219
KS
152 sd->effect_params2[i] / (1 << 16),
153 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
768c5251 154 }
45ecda85 155 av_log(avctx, AV_LOG_DEBUG, "\n");
768c5251
AD
156 }
157 }
45ecda85
AD
158 if (sd->effect_flag = get_bits1(gb))
159 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
768c5251
AD
160
161 if (get_bits_count(gb) >= gb->size_in_bits +
36ef5369 162 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
45ecda85 163 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
768c5251 164 if (get_bits_count(gb) < gb->size_in_bits - 8)
45ecda85
AD
165 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
166}
167
168static 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];
50f97219 180 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
45ecda85
AD
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);
50f97219 184 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
45ecda85 185 }
9abc80f1 186 alpha = av_clip_uint16(sd->coefs[1][6]);
45ecda85 187
7c6eb0a1 188 for (plane = 0; plane < (s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
45ecda85
AD
189 int width = v->output_width>>!!plane;
190
191 for (row = 0; row < v->output_height>>!!plane; row++) {
6792559f
AK
192 uint8_t *dst = v->sprite_output_frame->data[plane] +
193 v->sprite_output_frame->linesize[plane] * row;
45ecda85
AD
194
195 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
f6774f90 196 uint8_t *iplane = s->current_picture.f->data[plane];
197 int iline = s->current_picture.f->linesize[plane];
50f97219
KS
198 int ycoord = yoff[sprite] + yadv[sprite] * row;
199 int yline = ycoord >> 16;
2bf369b6 200 int next_line;
50f97219 201 ysub[sprite] = ycoord & 0xFFFF;
45ecda85 202 if (sprite) {
f6774f90 203 iplane = s->last_picture.f->data[plane];
204 iline = s->last_picture.f->linesize[plane];
45ecda85 205 }
2bf369b6 206 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
50f97219
KS
207 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
208 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
45ecda85 209 if (ysub[sprite])
2bf369b6 210 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
45ecda85
AD
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 {
50f97219 217 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
45ecda85
AD
218 sr_cache[sprite][0] = yline;
219 }
220 }
221 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
2bf369b6
MN
222 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
223 iplane + next_line, xoff[sprite],
224 xadv[sprite], width);
45ecda85
AD
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
265static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
266{
50f97219 267 MpegEncContext *s = &v->s;
45ecda85
AD
268 AVCodecContext *avctx = s->avctx;
269 SpriteData sd;
270
271 vc1_parse_sprites(v, gb, &sd);
272
f6774f90 273 if (!s->current_picture.f->data[0]) {
45ecda85
AD
274 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
275 return -1;
276 }
277
f6774f90 278 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
45ecda85
AD
279 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
280 v->two_sprites = 0;
281 }
282
6792559f
AK
283 av_frame_unref(v->sprite_output_frame);
284 if (ff_get_buffer(avctx, v->sprite_output_frame, 0) < 0) {
45ecda85
AD
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
294static void vc1_sprite_flush(AVCodecContext *avctx)
295{
50f97219 296 VC1Context *v = avctx->priv_data;
45ecda85 297 MpegEncContext *s = &v->s;
f6774f90 298 AVFrame *f = s->current_picture.f;
45ecda85
AD
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
68211c70 305 if (f && f->data[0])
7c6eb0a1 306 for (plane = 0; plane < (s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
45ecda85 307 for (i = 0; i < v->sprite_height>>!!plane; i++)
50f97219 308 memset(f->data[plane] + i * f->linesize[plane],
45ecda85 309 plane ? 128 : 0, f->linesize[plane]);
768c5251
AD
310}
311
45ecda85
AD
312#endif
313
7627c35a 314av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
d2f119a1
AD
315{
316 MpegEncContext *s = &v->s;
d909f43b 317 int i, ret = AVERROR(ENOMEM);
d8fd1836 318 int mb_height = FFALIGN(s->mb_height, 2);
d2f119a1
AD
319
320 /* Allocate mb bitplanes */
d8fd1836
MN
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);
e66fa353
VG
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;
d2f119a1
AD
330
331 v->n_allocated_blks = s->mb_width + 2;
50f97219
KS
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);
e66fa353
VG
334 if (!v->block || !v->cbp_base)
335 goto error;
50f97219
KS
336 v->cbp = v->cbp_base + s->mb_stride;
337 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
e66fa353
VG
338 if (!v->ttblk_base)
339 goto error;
50f97219
KS
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);
e66fa353
VG
342 if (!v->is_intra_base)
343 goto error;
50f97219
KS
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);
e66fa353
VG
346 if (!v->luma_mv_base)
347 goto error;
50f97219 348 v->luma_mv = v->luma_mv_base + s->mb_stride;
d2f119a1
AD
349
350 /* allocate block type info in that way so it could be used with s->block_index[] */
d8fd1836 351 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
e66fa353
VG
352 if (!v->mb_type_base)
353 goto error;
50f97219 354 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
d8fd1836
MN
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);
d2f119a1 357
cad16562 358 /* allocate memory to store block level MV info */
d8fd1836 359 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
e66fa353
VG
360 if (!v->blk_mv_type_base)
361 goto error;
50f97219 362 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
d8fd1836 363 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
e66fa353
VG
364 if (!v->mv_f_base)
365 goto error;
50f97219 366 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
d8fd1836
MN
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));
e66fa353
VG
369 if (!v->mv_f_next_base)
370 goto error;
50f97219 371 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
d8fd1836 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);
cad16562 373
36ef5369 374 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
01f0e6a0
VG
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 }
d2f119a1
AD
380 }
381
68127e1b 382 ret = ff_intrax8_common_init(&v->x8, &s->idsp, s);
d909f43b
VG
383 if (ret < 0)
384 goto error;
385
d2f119a1 386 return 0;
f91d94bd
VG
387
388error:
389 ff_vc1_decode_end(s->avctx);
d909f43b 390 return ret;
d2f119a1
AD
391}
392
7627c35a
KS
393av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
394{
395 int i;
396 for (i = 0; i < 64; i++) {
397#define transpose(x) ((x >> 3) | ((x & 7) << 3))
398 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
399 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
400 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
401 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
402 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
403 }
404 v->left_blk_sh = 0;
405 v->top_blk_sh = 3;
406}
407
b761659b
DB
408/** Initialize a VC1/WMV3 decoder
409 * @todo TODO: Handle VC-1 IDUs (Transport level?)
410 * @todo TODO: Decypher remaining bits in extra_data
411 */
412static av_cold int vc1_decode_init(AVCodecContext *avctx)
413{
414 VC1Context *v = avctx->priv_data;
415 MpegEncContext *s = &v->s;
416 GetBitContext gb;
417
45ecda85
AD
418 /* save the container output size for WMImage */
419 v->output_width = avctx->width;
420 v->output_height = avctx->height;
421
50f97219
KS
422 if (!avctx->extradata_size || !avctx->extradata)
423 return -1;
7c6eb0a1 424 if (!(avctx->flags & AV_CODEC_FLAG_GRAY))
632ad224 425 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
b761659b 426 else
716d413c 427 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
b761659b 428 v->s.avctx = avctx;
b761659b 429
c742ab4e 430 if (ff_vc1_init_common(v) < 0)
50f97219 431 return -1;
e74433a8 432 ff_blockdsp_init(&s->bdsp, avctx);
79dad2a9 433 ff_h264chroma_init(&v->h264chroma, 8);
368f5035 434 ff_qpeldsp_init(&s->qdsp);
b761659b 435
36ef5369 436 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
b761659b
DB
437 int count = 0;
438
439 // looks like WMV3 has a sequence header stored in the extradata
440 // advanced sequence header may be before the first frame
441 // the last byte of the extradata is a version number, 1 for the
442 // samples we can decode
443
444 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
445
5f2c159c 446 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
b761659b
DB
447 return -1;
448
449 count = avctx->extradata_size*8 - get_bits_count(&gb);
50f97219 450 if (count > 0) {
b761659b 451 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
072756cd 452 count, get_bits_long(&gb, FFMIN(count, 32)));
50f97219 453 } else if (count < 0) {
b761659b
DB
454 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
455 }
768c5251 456 } else { // VC1/WVC1/WVP2
b761659b
DB
457 const uint8_t *start = avctx->extradata;
458 uint8_t *end = avctx->extradata + avctx->extradata_size;
459 const uint8_t *next;
460 int size, buf2_size;
461 uint8_t *buf2 = NULL;
462 int seq_initialized = 0, ep_initialized = 0;
463
50f97219 464 if (avctx->extradata_size < 16) {
b761659b
DB
465 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
466 return -1;
467 }
468
059a9348 469 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
95ce961d 470 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
50f97219
KS
471 next = start;
472 for (; next < end; start = next) {
b761659b
DB
473 next = find_next_marker(start + 4, end);
474 size = next - start - 4;
50f97219
KS
475 if (size <= 0)
476 continue;
b761659b
DB
477 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
478 init_get_bits(&gb, buf2, buf2_size * 8);
50f97219 479 switch (AV_RB32(start)) {
b761659b 480 case VC1_CODE_SEQHDR:
5f2c159c 481 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
b761659b
DB
482 av_free(buf2);
483 return -1;
484 }
485 seq_initialized = 1;
486 break;
487 case VC1_CODE_ENTRYPOINT:
5f2c159c 488 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
b761659b
DB
489 av_free(buf2);
490 return -1;
491 }
492 ep_initialized = 1;
493 break;
494 }
495 }
496 av_free(buf2);
50f97219 497 if (!seq_initialized || !ep_initialized) {
b761659b
DB
498 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
499 return -1;
500 }
77bcb896 501 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
b761659b 502 }
7b20d35a 503
6792559f
AK
504 v->sprite_output_frame = av_frame_alloc();
505 if (!v->sprite_output_frame)
506 return AVERROR(ENOMEM);
507
0215006a
HL
508 avctx->profile = v->profile;
509 if (v->profile == PROFILE_ADVANCED)
510 avctx->level = v->level;
511
3dc99a18 512 avctx->has_b_frames = !!avctx->max_b_frames;
b761659b 513
1a02e786
VG
514 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
515 avctx->color_primaries = v->color_prim;
516 if (v->transfer_char == 1 || v->transfer_char == 7)
517 avctx->color_trc = v->transfer_char;
518 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
519 avctx->colorspace = v->matrix_coef;
520
50f97219
KS
521 s->mb_width = (avctx->coded_width + 15) >> 4;
522 s->mb_height = (avctx->coded_height + 15) >> 4;
b761659b 523
0b05864e 524 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
7627c35a 525 ff_vc1_init_transposed_scantables(v);
58bb6b7d 526 } else {
1fec0550 527 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
58bb6b7d
RB
528 v->left_blk_sh = 3;
529 v->top_blk_sh = 0;
530 }
531
36ef5369 532 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
45ecda85
AD
533 v->sprite_width = avctx->coded_width;
534 v->sprite_height = avctx->coded_height;
535
536 avctx->coded_width = avctx->width = v->output_width;
537 avctx->coded_height = avctx->height = v->output_height;
538
539 // prevent 16.16 overflows
50f97219
KS
540 if (v->sprite_width > 1 << 14 ||
541 v->sprite_height > 1 << 14 ||
542 v->output_width > 1 << 14 ||
543 v->output_height > 1 << 14) return -1;
45ecda85 544 }
b761659b
DB
545 return 0;
546}
547
d2f119a1
AD
548/** Close a VC1/WMV3 decoder
549 * @warning Initial try at using MpegEncContext stuff
550 */
7627c35a 551av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
d2f119a1
AD
552{
553 VC1Context *v = avctx->priv_data;
554 int i;
555
6792559f 556 av_frame_free(&v->sprite_output_frame);
759001c5 557
d2f119a1 558 for (i = 0; i < 4; i++)
50f97219 559 av_freep(&v->sr_rows[i >> 1][i & 1]);
d2f119a1
AD
560 av_freep(&v->hrd_rate);
561 av_freep(&v->hrd_buffer);
835f798c 562 ff_mpv_common_end(&v->s);
d2f119a1
AD
563 av_freep(&v->mv_type_mb_plane);
564 av_freep(&v->direct_mb_plane);
cad16562
MSS
565 av_freep(&v->forward_mb_plane);
566 av_freep(&v->fieldtx_plane);
d2f119a1
AD
567 av_freep(&v->acpred_plane);
568 av_freep(&v->over_flags_plane);
569 av_freep(&v->mb_type_base);
cad16562
MSS
570 av_freep(&v->blk_mv_type_base);
571 av_freep(&v->mv_f_base);
cad16562 572 av_freep(&v->mv_f_next_base);
d2f119a1
AD
573 av_freep(&v->block);
574 av_freep(&v->cbp_base);
575 av_freep(&v->ttblk_base);
576 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
577 av_freep(&v->luma_mv_base);
578 ff_intrax8_common_end(&v->x8);
579 return 0;
580}
581
b761659b
DB
582
583/** Decode a VC1/WMV3 frame
584 * @todo TODO: Handle VC-1 IDUs (Transport level?)
585 */
50f97219 586static int vc1_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 587 int *got_frame, AVPacket *avpkt)
b761659b
DB
588{
589 const uint8_t *buf = avpkt->data;
759001c5 590 int buf_size = avpkt->size, n_slices = 0, i, ret;
b761659b
DB
591 VC1Context *v = avctx->priv_data;
592 MpegEncContext *s = &v->s;
593 AVFrame *pict = data;
594 uint8_t *buf2 = NULL;
595 const uint8_t *buf_start = buf;
cad16562 596 int mb_height, n_slices1;
f44d6445
RB
597 struct {
598 uint8_t *buf;
599 GetBitContext gb;
600 int mby_start;
b797f735 601 } *slices = NULL, *tmp;
b761659b
DB
602
603 /* no supplementary picture */
fb985071 604 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
b761659b 605 /* special case for last picture */
50f97219 606 if (s->low_delay == 0 && s->next_picture_ptr) {
f6774f90 607 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
759001c5 608 return ret;
50f97219 609 s->next_picture_ptr = NULL;
b761659b 610
df9b9567 611 *got_frame = 1;
b761659b
DB
612 }
613
614 return 0;
615 }
616
b761659b 617 //for advanced profile we may need to parse and unescape data
36ef5369 618 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
b761659b 619 int buf_size2 = 0;
059a9348 620 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
b761659b 621
50f97219 622 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
b761659b
DB
623 const uint8_t *start, *end, *next;
624 int size;
625
626 next = buf;
50f97219 627 for (start = buf, end = buf + buf_size; next < end; start = next) {
b761659b
DB
628 next = find_next_marker(start + 4, end);
629 size = next - start - 4;
50f97219
KS
630 if (size <= 0) continue;
631 switch (AV_RB32(start)) {
b761659b 632 case VC1_CODE_FRAME:
578ea75a 633 if (avctx->hwaccel)
b761659b
DB
634 buf_start = start;
635 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
636 break;
cad16562
MSS
637 case VC1_CODE_FIELD: {
638 int buf_size3;
714f5ab5
JG
639 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
640 if (!tmp)
50f97219 641 goto err;
714f5ab5 642 slices = tmp;
059a9348 643 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
50f97219
KS
644 if (!slices[n_slices].buf)
645 goto err;
cad16562
MSS
646 buf_size3 = vc1_unescape_buffer(start + 4, size,
647 slices[n_slices].buf);
648 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
649 buf_size3 << 3);
650 /* assuming that the field marker is at the exact middle,
651 hope it's correct */
652 slices[n_slices].mby_start = s->mb_height >> 1;
653 n_slices1 = n_slices - 1; // index of the last slice of the first field
654 n_slices++;
cad16562
MSS
655 break;
656 }
b761659b
DB
657 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
658 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
50f97219 659 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5f2c159c 660 ff_vc1_decode_entry_point(avctx, v, &s->gb);
b761659b 661 break;
f44d6445
RB
662 case VC1_CODE_SLICE: {
663 int buf_size3;
714f5ab5
JG
664 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
665 if (!tmp)
50f97219 666 goto err;
714f5ab5 667 slices = tmp;
059a9348 668 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
50f97219
KS
669 if (!slices[n_slices].buf)
670 goto err;
f44d6445
RB
671 buf_size3 = vc1_unescape_buffer(start + 4, size,
672 slices[n_slices].buf);
673 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
674 buf_size3 << 3);
675 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
676 n_slices++;
677 break;
678 }
b761659b
DB
679 }
680 }
50f97219 681 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
b761659b 682 const uint8_t *divider;
0a6aff69 683 int buf_size3;
b761659b
DB
684
685 divider = find_next_marker(buf, buf + buf_size);
50f97219 686 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
b761659b 687 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
b81a935b 688 goto err;
cad16562 689 } else { // found field marker, unescape second field
0a6aff69
AD
690 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
691 if (!tmp)
692 goto err;
693 slices = tmp;
059a9348 694 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
0a6aff69
AD
695 if (!slices[n_slices].buf)
696 goto err;
697 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
698 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
699 buf_size3 << 3);
700 slices[n_slices].mby_start = s->mb_height >> 1;
701 n_slices1 = n_slices - 1;
702 n_slices++;
b761659b 703 }
b761659b 704 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
50f97219 705 } else {
b761659b
DB
706 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
707 }
708 init_get_bits(&s->gb, buf2, buf_size2*8);
709 } else
710 init_get_bits(&s->gb, buf, buf_size*8);
768c5251
AD
711
712 if (v->res_sprite) {
50f97219
KS
713 v->new_sprite = !get_bits1(&s->gb);
714 v->two_sprites = get_bits1(&s->gb);
36ef5369 715 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
45ecda85
AD
716 we're using the sprite compositor. These are intentionally kept separate
717 so you can get the raw sprites by using the wmv3 decoder for WMVP or
718 the vc1 one for WVP2 */
36ef5369 719 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
45ecda85
AD
720 if (v->new_sprite) {
721 // switch AVCodecContext parameters to those of the sprites
722 avctx->width = avctx->coded_width = v->sprite_width;
723 avctx->height = avctx->coded_height = v->sprite_height;
724 } else {
725 goto image;
726 }
727 }
768c5251
AD
728 }
729
d2f119a1
AD
730 if (s->context_initialized &&
731 (s->width != avctx->coded_width ||
732 s->height != avctx->coded_height)) {
7627c35a 733 ff_vc1_decode_end(avctx);
d2f119a1
AD
734 }
735
736 if (!s->context_initialized) {
b772b0e2 737 if (ff_msmpeg4_decode_init(avctx) < 0)
6f8ef532 738 goto err;
b772b0e2 739 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
835f798c 740 ff_mpv_common_end(s);
b772b0e2
MS
741 goto err;
742 }
d2f119a1
AD
743
744 s->low_delay = !avctx->has_b_frames || v->res_sprite;
745
746 if (v->profile == PROFILE_ADVANCED) {
747 s->h_edge_pos = avctx->coded_width;
748 s->v_edge_pos = avctx->coded_height;
749 }
750 }
751
b761659b 752 // do parse frame header
cad16562 753 v->pic_header_flag = 0;
4162fc62 754 v->first_pic_header_flag = 1;
50f97219 755 if (v->profile < PROFILE_ADVANCED) {
ec7d002e 756 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
b81a935b 757 goto err;
b761659b
DB
758 }
759 } else {
ec7d002e 760 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
b81a935b 761 goto err;
b761659b
DB
762 }
763 }
4162fc62 764 v->first_pic_header_flag = 0;
b761659b 765
36ef5369 766 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
50f97219 767 && s->pict_type != AV_PICTURE_TYPE_I) {
45ecda85
AD
768 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
769 goto err;
cba322d7
KS
770 }
771
8ed2ae09 772 // for skipping the frame
f6774f90 773 s->current_picture.f->pict_type = s->pict_type;
774 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
b761659b
DB
775
776 /* skip B-frames if we don't have reference frames */
f929ab05 777 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
cdf6eb5a 778 goto end;
b761659b 779 }
50f97219
KS
780 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
781 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
782 avctx->skip_frame >= AVDISCARD_ALL) {
b81a935b 783 goto end;
b761659b 784 }
b761659b 785
50f97219
KS
786 if (s->next_p_frame_damaged) {
787 if (s->pict_type == AV_PICTURE_TYPE_B)
b81a935b 788 goto end;
b761659b 789 else
50f97219 790 s->next_p_frame_damaged = 0;
b761659b
DB
791 }
792
835f798c 793 if (ff_mpv_frame_start(s, avctx) < 0) {
b81a935b 794 goto err;
b761659b
DB
795 }
796
ac1fc92e 797 // process pulldown flags
f6774f90 798 s->current_picture_ptr->f->repeat_pict = 0;
ac1fc92e
AK
799 // Pulldown flags are only valid when 'broadcast' has been set.
800 // So ticks_per_frame will be 2
801 if (v->rff) {
802 // repeat field
f6774f90 803 s->current_picture_ptr->f->repeat_pict = 1;
ac1fc92e
AK
804 } else if (v->rptfrm) {
805 // repeat frames
f6774f90 806 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
ac1fc92e
AK
807 }
808
368f5035
DB
809 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
810 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
b761659b 811
578ea75a 812 if (avctx->hwaccel) {
b761659b 813 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
b81a935b 814 goto err;
b761659b 815 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
b81a935b 816 goto err;
b761659b 817 if (avctx->hwaccel->end_frame(avctx) < 0)
b81a935b 818 goto err;
b761659b 819 } else {
bb7bf175
MN
820 int header_ret = 0;
821
54974c62 822 ff_mpeg_er_frame_start(s);
b761659b
DB
823
824 v->bits = buf_size * 8;
ee769c6a 825 v->end_mb_x = s->mb_width;
cad16562 826 if (v->field_mode) {
f6774f90 827 s->current_picture.f->linesize[0] <<= 1;
828 s->current_picture.f->linesize[1] <<= 1;
829 s->current_picture.f->linesize[2] <<= 1;
50f97219
KS
830 s->linesize <<= 1;
831 s->uvlinesize <<= 1;
cad16562
MSS
832 }
833 mb_height = s->mb_height >> v->field_mode;
43bacd5b
LB
834
835 if (!mb_height) {
836 av_log(v->s.avctx, AV_LOG_ERROR, "Invalid mb_height.\n");
837 goto err;
838 }
839
f44d6445 840 for (i = 0; i <= n_slices; i++) {
cad16562 841 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1100acba
MN
842 if (v->field_mode <= 0) {
843 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
844 "picture boundary (%d >= %d)\n", i,
845 slices[i - 1].mby_start, mb_height);
846 continue;
847 }
cad16562 848 v->second_field = 1;
50f97219 849 v->blocks_off = s->mb_width * s->mb_height << 1;
cad16562
MSS
850 v->mb_off = s->mb_stride * s->mb_height >> 1;
851 } else {
852 v->second_field = 0;
853 v->blocks_off = 0;
854 v->mb_off = 0;
855 }
856 if (i) {
857 v->pic_header_flag = 0;
0aa907cf 858 if (v->field_mode && i == n_slices1 + 2) {
bb7bf175 859 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
0aa907cf 860 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
23d6ba2c
MS
861 if (avctx->err_recognition & AV_EF_EXPLODE)
862 goto err;
0aa907cf
MN
863 continue;
864 }
865 } else if (get_bits1(&s->gb)) {
cad16562 866 v->pic_header_flag = 1;
bb7bf175 867 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
0aa907cf 868 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
23d6ba2c
MS
869 if (avctx->err_recognition & AV_EF_EXPLODE)
870 goto err;
0aa907cf
MN
871 continue;
872 }
cad16562
MSS
873 }
874 }
bb7bf175
MN
875 if (header_ret < 0)
876 continue;
cad16562
MSS
877 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
878 if (!v->field_mode || v->second_field)
879 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
880 else
510ef04a 881 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
7627c35a 882 ff_vc1_decode_blocks(v);
cad16562
MSS
883 if (i != n_slices)
884 s->gb = slices[i].gb;
885 }
886 if (v->field_mode) {
cad16562 887 v->second_field = 0;
f6774f90 888 s->current_picture.f->linesize[0] >>= 1;
889 s->current_picture.f->linesize[1] >>= 1;
890 s->current_picture.f->linesize[2] >>= 1;
50f97219
KS
891 s->linesize >>= 1;
892 s->uvlinesize >>= 1;
93b12812
MN
893 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
894 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
895 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
896 }
f44d6445 897 }
6a85dfc8 898 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1218777f 899 get_bits_count(&s->gb), s->gb.size_in_bits);
50f97219 900// if (get_bits_count(&s->gb) > buf_size * 8)
b761659b 901// return -1;
46430fd4
MN
902 if (!v->field_mode)
903 ff_er_frame_end(&s->er);
b761659b
DB
904 }
905
835f798c 906 ff_mpv_frame_end(s);
b761659b 907
36ef5369 908 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
45ecda85
AD
909image:
910 avctx->width = avctx->coded_width = v->output_width;
911 avctx->height = avctx->coded_height = v->output_height;
50f97219
KS
912 if (avctx->skip_frame >= AVDISCARD_NONREF)
913 goto end;
45ecda85 914#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
50f97219
KS
915 if (vc1_decode_sprites(v, &s->gb))
916 goto err;
45ecda85 917#endif
6792559f 918 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
759001c5 919 goto err;
df9b9567 920 *got_frame = 1;
45ecda85 921 } else {
50f97219 922 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
f6774f90 923 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
759001c5
AK
924 goto err;
925 ff_print_debug_info(s, s->current_picture_ptr);
de4ec972 926 *got_frame = 1;
4b1f5e50 927 } else if (s->last_picture_ptr) {
f6774f90 928 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
759001c5
AK
929 goto err;
930 ff_print_debug_info(s, s->last_picture_ptr);
df9b9567 931 *got_frame = 1;
50f97219 932 }
45ecda85
AD
933 }
934
b81a935b 935end:
b761659b 936 av_free(buf2);
f44d6445
RB
937 for (i = 0; i < n_slices; i++)
938 av_free(slices[i].buf);
939 av_free(slices);
b761659b 940 return buf_size;
b81a935b
RB
941
942err:
943 av_free(buf2);
f44d6445
RB
944 for (i = 0; i < n_slices; i++)
945 av_free(slices[i].buf);
946 av_free(slices);
b81a935b 947 return -1;
b761659b
DB
948}
949
950
8d061989 951static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
654c7446 952#if CONFIG_VC1_DXVA2_HWACCEL
8d061989
RB
953 AV_PIX_FMT_DXVA2_VLD,
954#endif
d8039ef8
SL
955#if CONFIG_VC1_D3D11VA_HWACCEL
956 AV_PIX_FMT_D3D11VA_VLD,
957#endif
654c7446 958#if CONFIG_VC1_VAAPI_HWACCEL
d264c720 959 AV_PIX_FMT_VAAPI,
8d061989 960#endif
654c7446 961#if CONFIG_VC1_VDPAU_HWACCEL
8d061989
RB
962 AV_PIX_FMT_VDPAU,
963#endif
964 AV_PIX_FMT_YUV420P,
965 AV_PIX_FMT_NONE
966};
967
d36beb3f 968AVCodec ff_vc1_decoder = {
ec6402b7 969 .name = "vc1",
b2bed932 970 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
ec6402b7 971 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 972 .id = AV_CODEC_ID_VC1,
ec6402b7
AK
973 .priv_data_size = sizeof(VC1Context),
974 .init = vc1_decode_init,
7627c35a 975 .close = ff_vc1_decode_end,
ec6402b7 976 .decode = vc1_decode_frame,
4dc8c838 977 .flush = ff_mpeg_flush,
def97856 978 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
8d061989 979 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
2c681139 980 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
b761659b
DB
981};
982
700363af 983#if CONFIG_WMV3_DECODER
d36beb3f 984AVCodec ff_wmv3_decoder = {
ec6402b7 985 .name = "wmv3",
b2bed932 986 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
ec6402b7 987 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 988 .id = AV_CODEC_ID_WMV3,
ec6402b7
AK
989 .priv_data_size = sizeof(VC1Context),
990 .init = vc1_decode_init,
7627c35a 991 .close = ff_vc1_decode_end,
ec6402b7 992 .decode = vc1_decode_frame,
4dc8c838 993 .flush = ff_mpeg_flush,
def97856 994 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
8d061989 995 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
2c681139 996 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
b761659b 997};
700363af 998#endif
b761659b 999
45ecda85
AD
1000#if CONFIG_WMV3IMAGE_DECODER
1001AVCodec ff_wmv3image_decoder = {
1002 .name = "wmv3image",
b2bed932 1003 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
45ecda85 1004 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1005 .id = AV_CODEC_ID_WMV3IMAGE,
45ecda85
AD
1006 .priv_data_size = sizeof(VC1Context),
1007 .init = vc1_decode_init,
7627c35a 1008 .close = ff_vc1_decode_end,
45ecda85 1009 .decode = vc1_decode_frame,
def97856 1010 .capabilities = AV_CODEC_CAP_DR1,
45ecda85 1011 .flush = vc1_sprite_flush,
6f6c0294
VG
1012 .pix_fmts = (const enum AVPixelFormat[]) {
1013 AV_PIX_FMT_YUV420P,
1014 AV_PIX_FMT_NONE
1015 },
45ecda85
AD
1016};
1017#endif
1018
1019#if CONFIG_VC1IMAGE_DECODER
1020AVCodec ff_vc1image_decoder = {
1021 .name = "vc1image",
b2bed932 1022 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
45ecda85 1023 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1024 .id = AV_CODEC_ID_VC1IMAGE,
45ecda85
AD
1025 .priv_data_size = sizeof(VC1Context),
1026 .init = vc1_decode_init,
7627c35a 1027 .close = ff_vc1_decode_end,
45ecda85 1028 .decode = vc1_decode_frame,
def97856 1029 .capabilities = AV_CODEC_CAP_DR1,
45ecda85 1030 .flush = vc1_sprite_flush,
6f6c0294
VG
1031 .pix_fmts = (const enum AVPixelFormat[]) {
1032 AV_PIX_FMT_YUV420P,
1033 AV_PIX_FMT_NONE
1034 },
45ecda85
AD
1035};
1036#endif