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
7 * This file is part of FFmpeg.
9 * FFmpeg 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.
14 * FFmpeg 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.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
35 #include "mpegvideo.h"
37 #include "msmpeg4data.h"
41 #include "libavutil/avassert.h"
44 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
46 typedef struct SpriteData {
48 * Transform coefficients for both sprites in 16.16 fixed point format,
49 * in the order they appear in the bitstream:
60 int effect_type, effect_flag;
61 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
62 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
65 static inline int get_fp_val(GetBitContext* gb)
67 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
70 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
74 switch (get_bits(gb, 2)) {
77 c[2] = get_fp_val(gb);
81 c[0] = c[4] = get_fp_val(gb);
82 c[2] = get_fp_val(gb);
85 c[0] = get_fp_val(gb);
86 c[2] = get_fp_val(gb);
87 c[4] = get_fp_val(gb);
90 c[0] = get_fp_val(gb);
91 c[1] = get_fp_val(gb);
92 c[2] = get_fp_val(gb);
93 c[3] = get_fp_val(gb);
94 c[4] = get_fp_val(gb);
97 c[5] = get_fp_val(gb);
99 c[6] = get_fp_val(gb);
104 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
106 AVCodecContext *avctx = v->s.avctx;
109 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
110 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
111 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
112 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
113 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
114 for (i = 0; i < 7; i++)
115 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
116 sd->coefs[sprite][i] / (1<<16),
117 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
118 av_log(avctx, AV_LOG_DEBUG, "\n");
122 if (sd->effect_type = get_bits_long(gb, 30)) {
123 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
125 vc1_sprite_parse_transform(gb, sd->effect_params1);
128 vc1_sprite_parse_transform(gb, sd->effect_params1);
129 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
132 for (i = 0; i < sd->effect_pcount1; i++)
133 sd->effect_params1[i] = get_fp_val(gb);
135 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
136 // effect 13 is simple alpha blending and matches the opacity above
137 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
138 for (i = 0; i < sd->effect_pcount1; i++)
139 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
140 sd->effect_params1[i] / (1 << 16),
141 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
142 av_log(avctx, AV_LOG_DEBUG, "\n");
145 sd->effect_pcount2 = get_bits(gb, 16);
146 if (sd->effect_pcount2 > 10) {
147 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
148 return AVERROR_INVALIDDATA;
149 } else if (sd->effect_pcount2) {
151 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
152 while (++i < sd->effect_pcount2) {
153 sd->effect_params2[i] = get_fp_val(gb);
154 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
155 sd->effect_params2[i] / (1 << 16),
156 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
158 av_log(avctx, AV_LOG_DEBUG, "\n");
161 if (sd->effect_flag = get_bits1(gb))
162 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
164 if (get_bits_count(gb) >= gb->size_in_bits +
165 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
166 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
167 return AVERROR_INVALIDDATA;
169 if (get_bits_count(gb) < gb->size_in_bits - 8)
170 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
175 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
177 int i, plane, row, sprite;
178 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
179 uint8_t* src_h[2][2];
180 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
182 MpegEncContext *s = &v->s;
184 for (i = 0; i <= v->two_sprites; i++) {
185 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
186 xadv[i] = sd->coefs[i][0];
187 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
188 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
190 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
191 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
193 alpha = av_clip_uint16(sd->coefs[1][6]);
195 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
196 int width = v->output_width>>!!plane;
198 for (row = 0; row < v->output_height>>!!plane; row++) {
199 uint8_t *dst = v->sprite_output_frame->data[plane] +
200 v->sprite_output_frame->linesize[plane] * row;
202 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
203 uint8_t *iplane = s->current_picture.f->data[plane];
204 int iline = s->current_picture.f->linesize[plane];
205 int ycoord = yoff[sprite] + yadv[sprite] * row;
206 int yline = ycoord >> 16;
208 ysub[sprite] = ycoord & 0xFFFF;
210 iplane = s->last_picture.f->data[plane];
211 iline = s->last_picture.f->linesize[plane];
213 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
214 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
215 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
217 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
219 if (sr_cache[sprite][0] != yline) {
220 if (sr_cache[sprite][1] == yline) {
221 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
222 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
224 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
225 sr_cache[sprite][0] = yline;
228 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
229 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
230 iplane + next_line, xoff[sprite],
231 xadv[sprite], width);
232 sr_cache[sprite][1] = yline + 1;
234 src_h[sprite][0] = v->sr_rows[sprite][0];
235 src_h[sprite][1] = v->sr_rows[sprite][1];
239 if (!v->two_sprites) {
241 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
243 memcpy(dst, src_h[0][0], width);
246 if (ysub[0] && ysub[1]) {
247 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
248 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
249 } else if (ysub[0]) {
250 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
251 src_h[1][0], alpha, width);
252 } else if (ysub[1]) {
253 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
254 src_h[0][0], (1<<16)-1-alpha, width);
256 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
262 for (i = 0; i <= v->two_sprites; i++) {
272 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
275 MpegEncContext *s = &v->s;
276 AVCodecContext *avctx = s->avctx;
279 memset(&sd, 0, sizeof(sd));
281 ret = vc1_parse_sprites(v, gb, &sd);
285 if (!s->current_picture.f || !s->current_picture.f->data[0]) {
286 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
287 return AVERROR_UNKNOWN;
290 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
291 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
295 av_frame_unref(v->sprite_output_frame);
296 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
299 vc1_draw_sprites(v, &sd);
304 static void vc1_sprite_flush(AVCodecContext *avctx)
306 VC1Context *v = avctx->priv_data;
307 MpegEncContext *s = &v->s;
308 AVFrame *f = s->current_picture.f;
311 /* Windows Media Image codecs have a convergence interval of two keyframes.
312 Since we can't enforce it, clear to black the missing sprite. This is
313 wrong but it looks better than doing nothing. */
316 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
317 for (i = 0; i < v->sprite_height>>!!plane; i++)
318 memset(f->data[plane] + i * f->linesize[plane],
319 plane ? 128 : 0, f->linesize[plane]);
324 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
326 MpegEncContext *s = &v->s;
327 int i, ret = AVERROR(ENOMEM);
328 int mb_height = FFALIGN(s->mb_height, 2);
330 /* Allocate mb bitplanes */
331 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
332 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
333 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
334 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
335 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
336 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
337 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
338 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
341 v->n_allocated_blks = s->mb_width + 2;
342 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
343 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
344 if (!v->block || !v->cbp_base)
346 v->cbp = v->cbp_base + 2 * s->mb_stride;
347 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
350 v->ttblk = v->ttblk_base + 2 * s->mb_stride;
351 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
352 if (!v->is_intra_base)
354 v->is_intra = v->is_intra_base + 2 * s->mb_stride;
355 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
356 if (!v->luma_mv_base)
358 v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
360 /* allocate block type info in that way so it could be used with s->block_index[] */
361 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362 if (!v->mb_type_base)
364 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
365 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
368 /* allocate memory to store block level MV info */
369 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370 if (!v->blk_mv_type_base)
372 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
373 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
376 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
377 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379 if (!v->mv_f_next_base)
381 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
382 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
384 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
385 for (i = 0; i < 4; i++)
386 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
387 return AVERROR(ENOMEM);
390 ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp,
391 s->block, s->block_last_index,
392 s->mb_width, s->mb_height);
399 ff_vc1_decode_end(s->avctx);
403 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
406 for (i = 0; i < 64; i++) {
407 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
408 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
409 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
410 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
411 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
412 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
418 /** Initialize a VC1/WMV3 decoder
419 * @todo TODO: Handle VC-1 IDUs (Transport level?)
420 * @todo TODO: Decipher remaining bits in extra_data
422 static av_cold int vc1_decode_init(AVCodecContext *avctx)
424 VC1Context *v = avctx->priv_data;
425 MpegEncContext *s = &v->s;
429 /* save the container output size for WMImage */
430 v->output_width = avctx->width;
431 v->output_height = avctx->height;
433 if (!avctx->extradata_size || !avctx->extradata)
434 return AVERROR_INVALIDDATA;
437 if ((ret = ff_vc1_init_common(v)) < 0)
440 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
443 // looks like WMV3 has a sequence header stored in the extradata
444 // advanced sequence header may be before the first frame
445 // the last byte of the extradata is a version number, 1 for the
446 // samples we can decode
448 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
450 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
453 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
454 avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
455 return AVERROR_PATCHWELCOME;
458 count = avctx->extradata_size*8 - get_bits_count(&gb);
460 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
461 count, get_bits_long(&gb, FFMIN(count, 32)));
462 } else if (count < 0) {
463 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
465 } else { // VC1/WVC1/WVP2
466 const uint8_t *start = avctx->extradata;
467 uint8_t *end = avctx->extradata + avctx->extradata_size;
470 uint8_t *buf2 = NULL;
471 int seq_initialized = 0, ep_initialized = 0;
473 if (avctx->extradata_size < 16) {
474 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
475 return AVERROR_INVALIDDATA;
478 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
480 return AVERROR(ENOMEM);
482 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
484 for (; next < end; start = next) {
485 next = find_next_marker(start + 4, end);
486 size = next - start - 4;
489 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
490 init_get_bits(&gb, buf2, buf2_size * 8);
491 switch (AV_RB32(start)) {
492 case VC1_CODE_SEQHDR:
493 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
499 case VC1_CODE_ENTRYPOINT:
500 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
509 if (!seq_initialized || !ep_initialized) {
510 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
511 return AVERROR_INVALIDDATA;
513 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
516 avctx->profile = v->profile;
517 if (v->profile == PROFILE_ADVANCED)
518 avctx->level = v->level;
520 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
521 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
523 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
524 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
525 avctx->color_range = AVCOL_RANGE_MPEG;
528 // ensure static VLC tables are initialized
529 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
531 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
533 // Hack to ensure the above functions will be called
534 // again once we know all necessary settings.
535 // That this is necessary might indicate a bug.
536 ff_vc1_decode_end(avctx);
538 ff_blockdsp_init(&s->bdsp, avctx);
539 ff_h264chroma_init(&v->h264chroma, 8);
540 ff_qpeldsp_init(&s->qdsp);
542 // Must happen after calling ff_vc1_decode_end
543 // to avoid de-allocating the sprite_output_frame
544 v->sprite_output_frame = av_frame_alloc();
545 if (!v->sprite_output_frame)
546 return AVERROR(ENOMEM);
548 avctx->has_b_frames = !!avctx->max_b_frames;
550 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
551 avctx->color_primaries = v->color_prim;
552 if (v->transfer_char == 1 || v->transfer_char == 7)
553 avctx->color_trc = v->transfer_char;
554 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
555 avctx->colorspace = v->matrix_coef;
557 s->mb_width = (avctx->coded_width + 15) >> 4;
558 s->mb_height = (avctx->coded_height + 15) >> 4;
560 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
561 ff_vc1_init_transposed_scantables(v);
563 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
568 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
569 v->sprite_width = avctx->coded_width;
570 v->sprite_height = avctx->coded_height;
572 avctx->coded_width = avctx->width = v->output_width;
573 avctx->coded_height = avctx->height = v->output_height;
575 // prevent 16.16 overflows
576 if (v->sprite_width > 1 << 14 ||
577 v->sprite_height > 1 << 14 ||
578 v->output_width > 1 << 14 ||
579 v->output_height > 1 << 14) {
580 ret = AVERROR_INVALIDDATA;
584 if ((v->sprite_width&1) || (v->sprite_height&1)) {
585 avpriv_request_sample(avctx, "odd sprites support");
586 ret = AVERROR_PATCHWELCOME;
592 av_frame_free(&v->sprite_output_frame);
596 /** Close a VC1/WMV3 decoder
597 * @warning Initial try at using MpegEncContext stuff
599 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
601 VC1Context *v = avctx->priv_data;
604 av_frame_free(&v->sprite_output_frame);
606 for (i = 0; i < 4; i++)
607 av_freep(&v->sr_rows[i >> 1][i & 1]);
608 av_freep(&v->hrd_rate);
609 av_freep(&v->hrd_buffer);
610 ff_mpv_common_end(&v->s);
611 av_freep(&v->mv_type_mb_plane);
612 av_freep(&v->direct_mb_plane);
613 av_freep(&v->forward_mb_plane);
614 av_freep(&v->fieldtx_plane);
615 av_freep(&v->acpred_plane);
616 av_freep(&v->over_flags_plane);
617 av_freep(&v->mb_type_base);
618 av_freep(&v->blk_mv_type_base);
619 av_freep(&v->mv_f_base);
620 av_freep(&v->mv_f_next_base);
622 av_freep(&v->cbp_base);
623 av_freep(&v->ttblk_base);
624 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
625 av_freep(&v->luma_mv_base);
626 ff_intrax8_common_end(&v->x8);
631 /** Decode a VC1/WMV3 frame
632 * @todo TODO: Handle VC-1 IDUs (Transport level?)
634 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
635 int *got_frame, AVPacket *avpkt)
637 const uint8_t *buf = avpkt->data;
638 int buf_size = avpkt->size, n_slices = 0, i, ret;
639 VC1Context *v = avctx->priv_data;
640 MpegEncContext *s = &v->s;
641 AVFrame *pict = data;
642 uint8_t *buf2 = NULL;
643 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
644 int mb_height, n_slices1=-1;
649 const uint8_t *rawbuf;
651 } *slices = NULL, *tmp;
655 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
658 /* no supplementary picture */
659 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
660 /* special case for last picture */
661 if (s->low_delay == 0 && s->next_picture_ptr) {
662 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
664 s->next_picture_ptr = NULL;
672 //for advanced profile we may need to parse and unescape data
673 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
675 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
677 return AVERROR(ENOMEM);
679 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
680 const uint8_t *start, *end, *next;
684 for (start = buf, end = buf + buf_size; next < end; start = next) {
685 next = find_next_marker(start + 4, end);
686 size = next - start - 4;
687 if (size <= 0) continue;
688 switch (AV_RB32(start)) {
692 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
694 case VC1_CODE_FIELD: {
697 buf_start_second_field = start;
698 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
700 ret = AVERROR(ENOMEM);
704 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
705 if (!slices[n_slices].buf) {
706 ret = AVERROR(ENOMEM);
709 buf_size3 = vc1_unescape_buffer(start + 4, size,
710 slices[n_slices].buf);
711 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
713 slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
714 slices[n_slices].rawbuf = start;
715 slices[n_slices].raw_size = size + 4;
716 n_slices1 = n_slices - 1; // index of the last slice of the first field
720 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
721 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
722 init_get_bits(&s->gb, buf2, buf_size2 * 8);
723 ff_vc1_decode_entry_point(avctx, v, &s->gb);
725 case VC1_CODE_SLICE: {
727 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
729 ret = AVERROR(ENOMEM);
733 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
734 if (!slices[n_slices].buf) {
735 ret = AVERROR(ENOMEM);
738 buf_size3 = vc1_unescape_buffer(start + 4, size,
739 slices[n_slices].buf);
740 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
742 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
743 slices[n_slices].rawbuf = start;
744 slices[n_slices].raw_size = size + 4;
750 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
751 const uint8_t *divider;
754 divider = find_next_marker(buf, buf + buf_size);
755 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
756 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
757 ret = AVERROR_INVALIDDATA;
759 } else { // found field marker, unescape second field
761 buf_start_second_field = divider;
762 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
764 ret = AVERROR(ENOMEM);
768 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
769 if (!slices[n_slices].buf) {
770 ret = AVERROR(ENOMEM);
773 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
774 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
776 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
777 slices[n_slices].rawbuf = divider;
778 slices[n_slices].raw_size = buf + buf_size - divider;
779 n_slices1 = n_slices - 1;
782 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
784 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
786 init_get_bits(&s->gb, buf2, buf_size2*8);
788 init_get_bits(&s->gb, buf, buf_size*8);
791 v->new_sprite = !get_bits1(&s->gb);
792 v->two_sprites = get_bits1(&s->gb);
793 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
794 we're using the sprite compositor. These are intentionally kept separate
795 so you can get the raw sprites by using the wmv3 decoder for WMVP or
796 the vc1 one for WVP2 */
797 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
799 // switch AVCodecContext parameters to those of the sprites
800 avctx->width = avctx->coded_width = v->sprite_width;
801 avctx->height = avctx->coded_height = v->sprite_height;
808 if (s->context_initialized &&
809 (s->width != avctx->coded_width ||
810 s->height != avctx->coded_height)) {
811 ff_vc1_decode_end(avctx);
814 if (!s->context_initialized) {
815 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
817 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
818 ff_mpv_common_end(s);
822 s->low_delay = !avctx->has_b_frames || v->res_sprite;
824 if (v->profile == PROFILE_ADVANCED) {
825 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
826 ret = AVERROR_INVALIDDATA;
829 s->h_edge_pos = avctx->coded_width;
830 s->v_edge_pos = avctx->coded_height;
834 // do parse frame header
835 v->pic_header_flag = 0;
836 v->first_pic_header_flag = 1;
837 if (v->profile < PROFILE_ADVANCED) {
838 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
842 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
846 v->first_pic_header_flag = 0;
848 if (avctx->debug & FF_DEBUG_PICT_INFO)
849 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
851 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
852 && s->pict_type != AV_PICTURE_TYPE_I) {
853 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
854 ret = AVERROR_INVALIDDATA;
857 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
859 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
860 ret = AVERROR_INVALIDDATA;
863 if ((s->mb_height >> v->field_mode) == 0) {
864 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
865 ret = AVERROR_INVALIDDATA;
869 // for skipping the frame
870 s->current_picture.f->pict_type = s->pict_type;
871 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
873 /* skip B-frames if we don't have reference frames */
874 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
875 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
878 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
879 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
880 avctx->skip_frame >= AVDISCARD_ALL) {
884 if (s->next_p_frame_damaged) {
885 if (s->pict_type == AV_PICTURE_TYPE_B)
888 s->next_p_frame_damaged = 0;
891 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
895 v->s.current_picture_ptr->field_picture = v->field_mode;
896 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
897 v->s.current_picture_ptr->f->top_field_first = v->tff;
899 // process pulldown flags
900 s->current_picture_ptr->f->repeat_pict = 0;
901 // Pulldown flags are only valid when 'broadcast' has been set.
902 // So ticks_per_frame will be 2
905 s->current_picture_ptr->f->repeat_pict = 1;
906 } else if (v->rptfrm) {
908 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
911 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
912 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
914 if (avctx->hwaccel) {
916 if (v->field_mode && buf_start_second_field) {
917 // decode first field
918 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
919 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
922 if (n_slices1 == -1) {
923 // no slices, decode the field as-is
924 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
927 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
930 for (i = 0 ; i < n_slices1 + 1; i++) {
931 s->gb = slices[i].gb;
932 s->mb_y = slices[i].mby_start;
934 v->pic_header_flag = get_bits1(&s->gb);
935 if (v->pic_header_flag) {
936 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
937 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
938 ret = AVERROR_INVALIDDATA;
939 if (avctx->err_recognition & AV_EF_EXPLODE)
945 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
950 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
953 // decode second field
954 s->gb = slices[n_slices1 + 1].gb;
955 s->mb_y = slices[n_slices1 + 1].mby_start;
956 s->picture_structure = PICT_TOP_FIELD + v->tff;
958 v->pic_header_flag = 0;
959 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
960 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
961 ret = AVERROR_INVALIDDATA;
964 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
966 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
969 if (n_slices - n_slices1 == 2) {
970 // no slices, decode the field as-is
971 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
974 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
977 for (i = n_slices1 + 2; i < n_slices; i++) {
978 s->gb = slices[i].gb;
979 s->mb_y = slices[i].mby_start;
981 v->pic_header_flag = get_bits1(&s->gb);
982 if (v->pic_header_flag) {
983 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
984 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
985 ret = AVERROR_INVALIDDATA;
986 if (avctx->err_recognition & AV_EF_EXPLODE)
992 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
997 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1000 s->picture_structure = PICT_FRAME;
1001 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1004 if (n_slices == 0) {
1005 // no slices, decode the frame as-is
1006 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1009 // decode the frame part as the first slice
1010 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1013 // and process the slices as additional slices afterwards
1014 for (i = 0 ; i < n_slices; i++) {
1015 s->gb = slices[i].gb;
1016 s->mb_y = slices[i].mby_start;
1018 v->pic_header_flag = get_bits1(&s->gb);
1019 if (v->pic_header_flag) {
1020 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1021 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1022 ret = AVERROR_INVALIDDATA;
1023 if (avctx->err_recognition & AV_EF_EXPLODE)
1029 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1033 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1039 ff_mpeg_er_frame_start(s);
1041 v->end_mb_x = s->mb_width;
1042 if (v->field_mode) {
1043 s->current_picture.f->linesize[0] <<= 1;
1044 s->current_picture.f->linesize[1] <<= 1;
1045 s->current_picture.f->linesize[2] <<= 1;
1047 s->uvlinesize <<= 1;
1049 mb_height = s->mb_height >> v->field_mode;
1051 av_assert0 (mb_height > 0);
1053 for (i = 0; i <= n_slices; i++) {
1054 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1055 if (v->field_mode <= 0) {
1056 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1057 "picture boundary (%d >= %d)\n", i,
1058 slices[i - 1].mby_start, mb_height);
1061 v->second_field = 1;
1062 av_assert0((s->mb_height & 1) == 0);
1063 v->blocks_off = s->b8_stride * (s->mb_height&~1);
1064 v->mb_off = s->mb_stride * s->mb_height >> 1;
1066 v->second_field = 0;
1071 v->pic_header_flag = 0;
1072 if (v->field_mode && i == n_slices1 + 2) {
1073 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1074 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1075 ret = AVERROR_INVALIDDATA;
1076 if (avctx->err_recognition & AV_EF_EXPLODE)
1080 } else if (get_bits1(&s->gb)) {
1081 v->pic_header_flag = 1;
1082 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1083 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1084 ret = AVERROR_INVALIDDATA;
1085 if (avctx->err_recognition & AV_EF_EXPLODE)
1093 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1094 if (!v->field_mode || v->second_field)
1095 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1097 if (i >= n_slices) {
1098 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1101 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1103 if (s->end_mb_y <= s->start_mb_y) {
1104 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1107 if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1108 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1110 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1113 ff_vc1_decode_blocks(v);
1114 if (i != n_slices) {
1115 s->gb = slices[i].gb;
1118 if (v->field_mode) {
1119 v->second_field = 0;
1120 s->current_picture.f->linesize[0] >>= 1;
1121 s->current_picture.f->linesize[1] >>= 1;
1122 s->current_picture.f->linesize[2] >>= 1;
1124 s->uvlinesize >>= 1;
1125 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1126 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1127 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1130 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1131 get_bits_count(&s->gb), s->gb.size_in_bits);
1132 // if (get_bits_count(&s->gb) > buf_size * 8)
1134 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1135 ret = AVERROR_INVALIDDATA;
1139 ff_er_frame_end(&s->er);
1142 ff_mpv_frame_end(s);
1144 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1146 avctx->width = avctx->coded_width = v->output_width;
1147 avctx->height = avctx->coded_height = v->output_height;
1148 if (avctx->skip_frame >= AVDISCARD_NONREF)
1150 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1151 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1154 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1158 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1159 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1161 ff_print_debug_info(s, s->current_picture_ptr, pict);
1163 } else if (s->last_picture_ptr) {
1164 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1166 ff_print_debug_info(s, s->last_picture_ptr, pict);
1173 for (i = 0; i < n_slices; i++)
1174 av_free(slices[i].buf);
1180 for (i = 0; i < n_slices; i++)
1181 av_free(slices[i].buf);
1187 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1188 #if CONFIG_VC1_DXVA2_HWACCEL
1189 AV_PIX_FMT_DXVA2_VLD,
1191 #if CONFIG_VC1_D3D11VA_HWACCEL
1192 AV_PIX_FMT_D3D11VA_VLD,
1195 #if CONFIG_VC1_NVDEC_HWACCEL
1198 #if CONFIG_VC1_VAAPI_HWACCEL
1201 #if CONFIG_VC1_VDPAU_HWACCEL
1208 AVCodec ff_vc1_decoder = {
1210 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1211 .type = AVMEDIA_TYPE_VIDEO,
1212 .id = AV_CODEC_ID_VC1,
1213 .priv_data_size = sizeof(VC1Context),
1214 .init = vc1_decode_init,
1215 .close = ff_vc1_decode_end,
1216 .decode = vc1_decode_frame,
1217 .flush = ff_mpeg_flush,
1218 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1219 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1220 .hw_configs = (const AVCodecHWConfigInternal*[]) {
1221 #if CONFIG_VC1_DXVA2_HWACCEL
1224 #if CONFIG_VC1_D3D11VA_HWACCEL
1225 HWACCEL_D3D11VA(vc1),
1227 #if CONFIG_VC1_D3D11VA2_HWACCEL
1228 HWACCEL_D3D11VA2(vc1),
1230 #if CONFIG_VC1_NVDEC_HWACCEL
1233 #if CONFIG_VC1_VAAPI_HWACCEL
1236 #if CONFIG_VC1_VDPAU_HWACCEL
1241 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1244 #if CONFIG_WMV3_DECODER
1245 AVCodec ff_wmv3_decoder = {
1247 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1248 .type = AVMEDIA_TYPE_VIDEO,
1249 .id = AV_CODEC_ID_WMV3,
1250 .priv_data_size = sizeof(VC1Context),
1251 .init = vc1_decode_init,
1252 .close = ff_vc1_decode_end,
1253 .decode = vc1_decode_frame,
1254 .flush = ff_mpeg_flush,
1255 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1256 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1257 .hw_configs = (const AVCodecHWConfigInternal*[]) {
1258 #if CONFIG_WMV3_DXVA2_HWACCEL
1259 HWACCEL_DXVA2(wmv3),
1261 #if CONFIG_WMV3_D3D11VA_HWACCEL
1262 HWACCEL_D3D11VA(wmv3),
1264 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1265 HWACCEL_D3D11VA2(wmv3),
1267 #if CONFIG_WMV3_NVDEC_HWACCEL
1268 HWACCEL_NVDEC(wmv3),
1270 #if CONFIG_WMV3_VAAPI_HWACCEL
1271 HWACCEL_VAAPI(wmv3),
1273 #if CONFIG_WMV3_VDPAU_HWACCEL
1274 HWACCEL_VDPAU(wmv3),
1278 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1282 #if CONFIG_WMV3IMAGE_DECODER
1283 AVCodec ff_wmv3image_decoder = {
1284 .name = "wmv3image",
1285 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1286 .type = AVMEDIA_TYPE_VIDEO,
1287 .id = AV_CODEC_ID_WMV3IMAGE,
1288 .priv_data_size = sizeof(VC1Context),
1289 .init = vc1_decode_init,
1290 .close = ff_vc1_decode_end,
1291 .decode = vc1_decode_frame,
1292 .capabilities = AV_CODEC_CAP_DR1,
1293 .flush = vc1_sprite_flush,
1294 .pix_fmts = (const enum AVPixelFormat[]) {
1301 #if CONFIG_VC1IMAGE_DECODER
1302 AVCodec ff_vc1image_decoder = {
1304 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1305 .type = AVMEDIA_TYPE_VIDEO,
1306 .id = AV_CODEC_ID_VC1IMAGE,
1307 .priv_data_size = sizeof(VC1Context),
1308 .init = vc1_decode_init,
1309 .close = ff_vc1_decode_end,
1310 .decode = vc1_decode_frame,
1311 .capabilities = AV_CODEC_CAP_DR1,
1312 .flush = vc1_sprite_flush,
1313 .pix_fmts = (const enum AVPixelFormat[]) {