FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vc1dec.c
Go to the documentation of this file.
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 FFmpeg.
8  *
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.
13  *
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.
18  *
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
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 "msmpeg4data.h"
36 #include "vc1.h"
37 #include "vc1data.h"
38 #include "vdpau_internal.h"
39 #include "libavutil/avassert.h"
40 
41 
42 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
43 
44 typedef struct SpriteData {
45  /**
46  * Transform coefficients for both sprites in 16.16 fixed point format,
47  * in the order they appear in the bitstream:
48  * x scale
49  * rotation 1 (unused)
50  * x offset
51  * rotation 2 (unused)
52  * y scale
53  * y offset
54  * alpha
55  */
56  int coefs[2][7];
57 
58  int effect_type, effect_flag;
59  int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
60  int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
61 } SpriteData;
62 
63 static inline int get_fp_val(GetBitContext* gb)
64 {
65  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
66 }
67 
68 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
69 {
70  c[1] = c[3] = 0;
71 
72  switch (get_bits(gb, 2)) {
73  case 0:
74  c[0] = 1 << 16;
75  c[2] = get_fp_val(gb);
76  c[4] = 1 << 16;
77  break;
78  case 1:
79  c[0] = c[4] = get_fp_val(gb);
80  c[2] = get_fp_val(gb);
81  break;
82  case 2:
83  c[0] = get_fp_val(gb);
84  c[2] = get_fp_val(gb);
85  c[4] = get_fp_val(gb);
86  break;
87  case 3:
88  c[0] = get_fp_val(gb);
89  c[1] = get_fp_val(gb);
90  c[2] = get_fp_val(gb);
91  c[3] = get_fp_val(gb);
92  c[4] = get_fp_val(gb);
93  break;
94  }
95  c[5] = get_fp_val(gb);
96  if (get_bits1(gb))
97  c[6] = get_fp_val(gb);
98  else
99  c[6] = 1 << 16;
100 }
101 
102 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
103 {
104  AVCodecContext *avctx = v->s.avctx;
105  int sprite, i;
106 
107  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
108  vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
109  if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
110  avpriv_request_sample(avctx, "Non-zero rotation coefficients");
111  av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
112  for (i = 0; i < 7; i++)
113  av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
114  sd->coefs[sprite][i] / (1<<16),
115  (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
116  av_log(avctx, AV_LOG_DEBUG, "\n");
117  }
118 
119  skip_bits(gb, 2);
120  if (sd->effect_type = get_bits_long(gb, 30)) {
121  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
122  case 7:
123  vc1_sprite_parse_transform(gb, sd->effect_params1);
124  break;
125  case 14:
126  vc1_sprite_parse_transform(gb, sd->effect_params1);
127  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
128  break;
129  default:
130  for (i = 0; i < sd->effect_pcount1; i++)
131  sd->effect_params1[i] = get_fp_val(gb);
132  }
133  if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
134  // effect 13 is simple alpha blending and matches the opacity above
135  av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
136  for (i = 0; i < sd->effect_pcount1; i++)
137  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
138  sd->effect_params1[i] / (1 << 16),
139  (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
140  av_log(avctx, AV_LOG_DEBUG, "\n");
141  }
142 
143  sd->effect_pcount2 = get_bits(gb, 16);
144  if (sd->effect_pcount2 > 10) {
145  av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
146  return AVERROR_INVALIDDATA;
147  } else if (sd->effect_pcount2) {
148  i = -1;
149  av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
150  while (++i < sd->effect_pcount2) {
151  sd->effect_params2[i] = get_fp_val(gb);
152  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
153  sd->effect_params2[i] / (1 << 16),
154  (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
155  }
156  av_log(avctx, AV_LOG_DEBUG, "\n");
157  }
158  }
159  if (sd->effect_flag = get_bits1(gb))
160  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
161 
162  if (get_bits_count(gb) >= gb->size_in_bits +
163  (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
164  av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
165  return AVERROR_INVALIDDATA;
166  }
167  if (get_bits_count(gb) < gb->size_in_bits - 8)
168  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
169 
170  return 0;
171 }
172 
173 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
174 {
175  int i, plane, row, sprite;
176  int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
177  uint8_t* src_h[2][2];
178  int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
179  int ysub[2];
180  MpegEncContext *s = &v->s;
181 
182  for (i = 0; i <= v->two_sprites; i++) {
183  xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
184  xadv[i] = sd->coefs[i][0];
185  if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
186  xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
187 
188  yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
189  yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
190  }
191  alpha = av_clip_uint16(sd->coefs[1][6]);
192 
193  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
194  int width = v->output_width>>!!plane;
195 
196  for (row = 0; row < v->output_height>>!!plane; row++) {
197  uint8_t *dst = v->sprite_output_frame->data[plane] +
199 
200  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
201  uint8_t *iplane = s->current_picture.f->data[plane];
202  int iline = s->current_picture.f->linesize[plane];
203  int ycoord = yoff[sprite] + yadv[sprite] * row;
204  int yline = ycoord >> 16;
205  int next_line;
206  ysub[sprite] = ycoord & 0xFFFF;
207  if (sprite) {
208  iplane = s->last_picture.f->data[plane];
209  iline = s->last_picture.f->linesize[plane];
210  }
211  next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
212  if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
213  src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
214  if (ysub[sprite])
215  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
216  } else {
217  if (sr_cache[sprite][0] != yline) {
218  if (sr_cache[sprite][1] == yline) {
219  FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
220  FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
221  } else {
222  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
223  sr_cache[sprite][0] = yline;
224  }
225  }
226  if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
227  v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
228  iplane + next_line, xoff[sprite],
229  xadv[sprite], width);
230  sr_cache[sprite][1] = yline + 1;
231  }
232  src_h[sprite][0] = v->sr_rows[sprite][0];
233  src_h[sprite][1] = v->sr_rows[sprite][1];
234  }
235  }
236 
237  if (!v->two_sprites) {
238  if (ysub[0]) {
239  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
240  } else {
241  memcpy(dst, src_h[0][0], width);
242  }
243  } else {
244  if (ysub[0] && ysub[1]) {
245  v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
246  src_h[1][0], src_h[1][1], ysub[1], alpha, width);
247  } else if (ysub[0]) {
248  v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
249  src_h[1][0], alpha, width);
250  } else if (ysub[1]) {
251  v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
252  src_h[0][0], (1<<16)-1-alpha, width);
253  } else {
254  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
255  }
256  }
257  }
258 
259  if (!plane) {
260  for (i = 0; i <= v->two_sprites; i++) {
261  xoff[i] >>= 1;
262  yoff[i] >>= 1;
263  }
264  }
265 
266  }
267 }
268 
269 
270 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
271 {
272  int ret;
273  MpegEncContext *s = &v->s;
274  AVCodecContext *avctx = s->avctx;
275  SpriteData sd;
276 
277  memset(&sd, 0, sizeof(sd));
278 
279  ret = vc1_parse_sprites(v, gb, &sd);
280  if (ret < 0)
281  return ret;
282 
283  if (!s->current_picture.f || !s->current_picture.f->data[0]) {
284  av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
285  return -1;
286  }
287 
288  if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
289  av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
290  v->two_sprites = 0;
291  }
292 
294  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
295  return ret;
296 
297  vc1_draw_sprites(v, &sd);
298 
299  return 0;
300 }
301 
302 static void vc1_sprite_flush(AVCodecContext *avctx)
303 {
304  VC1Context *v = avctx->priv_data;
305  MpegEncContext *s = &v->s;
306  AVFrame *f = s->current_picture.f;
307  int plane, i;
308 
309  /* Windows Media Image codecs have a convergence interval of two keyframes.
310  Since we can't enforce it, clear to black the missing sprite. This is
311  wrong but it looks better than doing nothing. */
312 
313  if (f && f->data[0])
314  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
315  for (i = 0; i < v->sprite_height>>!!plane; i++)
316  memset(f->data[plane] + i * f->linesize[plane],
317  plane ? 128 : 0, f->linesize[plane]);
318 }
319 
320 #endif
321 
323 {
324  MpegEncContext *s = &v->s;
325  int i;
326  int mb_height = FFALIGN(s->mb_height, 2);
327 
328  /* Allocate mb bitplanes */
329  v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
330  v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
331  v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
332  v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
333  v->acpred_plane = av_malloc (s->mb_stride * mb_height);
334  v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
335 
336  v->n_allocated_blks = s->mb_width + 2;
337  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
338  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
339  v->cbp = v->cbp_base + s->mb_stride;
340  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
341  v->ttblk = v->ttblk_base + s->mb_stride;
342  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
343  v->is_intra = v->is_intra_base + s->mb_stride;
344  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
345  v->luma_mv = v->luma_mv_base + s->mb_stride;
346 
347  /* allocate block type info in that way so it could be used with s->block_index[] */
348  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
349  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
350  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
351  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
352 
353  /* allocate memory to store block level MV info */
354  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
355  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
356  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
357  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
358  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
359  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
360  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
361  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362 
363  /* Init coded blocks info */
364  if (v->profile == PROFILE_ADVANCED) {
365 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
366 // return -1;
367 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
368 // return -1;
369  }
370 
371  ff_intrax8_common_init(&v->x8,s);
372 
374  for (i = 0; i < 4; i++)
375  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
376  return AVERROR(ENOMEM);
377  }
378 
379  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
380  !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
381  !v->mb_type_base) {
384  av_freep(&v->acpred_plane);
386  av_freep(&v->block);
387  av_freep(&v->cbp_base);
388  av_freep(&v->ttblk_base);
389  av_freep(&v->is_intra_base);
390  av_freep(&v->luma_mv_base);
391  av_freep(&v->mb_type_base);
392  return AVERROR(ENOMEM);
393  }
394 
395  return 0;
396 }
397 
399 {
400  int i;
401  for (i = 0; i < 64; i++) {
402 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
403  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
404  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
405  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
406  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
408  }
409  v->left_blk_sh = 0;
410  v->top_blk_sh = 3;
411 }
412 
413 /** Initialize a VC1/WMV3 decoder
414  * @todo TODO: Handle VC-1 IDUs (Transport level?)
415  * @todo TODO: Decypher remaining bits in extra_data
416  */
418 {
419  VC1Context *v = avctx->priv_data;
420  MpegEncContext *s = &v->s;
421  GetBitContext gb;
422  int ret;
423 
424  /* save the container output size for WMImage */
425  v->output_width = avctx->width;
426  v->output_height = avctx->height;
427 
428  if (!avctx->extradata_size || !avctx->extradata)
429  return -1;
430  if (!(avctx->flags & CODEC_FLAG_GRAY))
431  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
432  else
433  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
434  v->s.avctx = avctx;
435 
436  if ((ret = ff_vc1_init_common(v)) < 0)
437  return ret;
438  // ensure static VLC tables are initialized
439  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
440  return ret;
441  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
442  return ret;
443  // Hack to ensure the above functions will be called
444  // again once we know all necessary settings.
445  // That this is necessary might indicate a bug.
446  ff_vc1_decode_end(avctx);
447 
448  ff_blockdsp_init(&s->bdsp, avctx);
450  ff_qpeldsp_init(&s->qdsp);
451 
452  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
453  int count = 0;
454 
455  // looks like WMV3 has a sequence header stored in the extradata
456  // advanced sequence header may be before the first frame
457  // the last byte of the extradata is a version number, 1 for the
458  // samples we can decode
459 
460  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
461 
462  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
463  return ret;
464 
465  count = avctx->extradata_size*8 - get_bits_count(&gb);
466  if (count > 0) {
467  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
468  count, get_bits(&gb, count));
469  } else if (count < 0) {
470  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
471  }
472  } else { // VC1/WVC1/WVP2
473  const uint8_t *start = avctx->extradata;
474  uint8_t *end = avctx->extradata + avctx->extradata_size;
475  const uint8_t *next;
476  int size, buf2_size;
477  uint8_t *buf2 = NULL;
478  int seq_initialized = 0, ep_initialized = 0;
479 
480  if (avctx->extradata_size < 16) {
481  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
482  return -1;
483  }
484 
486  if (!buf2)
487  return AVERROR(ENOMEM);
488 
489  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
490  next = start;
491  for (; next < end; start = next) {
492  next = find_next_marker(start + 4, end);
493  size = next - start - 4;
494  if (size <= 0)
495  continue;
496  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
497  init_get_bits(&gb, buf2, buf2_size * 8);
498  switch (AV_RB32(start)) {
499  case VC1_CODE_SEQHDR:
500  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
501  av_free(buf2);
502  return ret;
503  }
504  seq_initialized = 1;
505  break;
506  case VC1_CODE_ENTRYPOINT:
507  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
508  av_free(buf2);
509  return ret;
510  }
511  ep_initialized = 1;
512  break;
513  }
514  }
515  av_free(buf2);
516  if (!seq_initialized || !ep_initialized) {
517  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
518  return -1;
519  }
520  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
521  }
522 
524  if (!v->sprite_output_frame)
525  return AVERROR(ENOMEM);
526 
527  avctx->profile = v->profile;
528  if (v->profile == PROFILE_ADVANCED)
529  avctx->level = v->level;
530 
531  avctx->has_b_frames = !!avctx->max_b_frames;
532 
533  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
534  avctx->color_primaries = v->color_prim;
535  if (v->transfer_char == 1 || v->transfer_char == 7)
536  avctx->color_trc = v->transfer_char;
537  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
538  avctx->colorspace = v->matrix_coef;
539 
540  s->mb_width = (avctx->coded_width + 15) >> 4;
541  s->mb_height = (avctx->coded_height + 15) >> 4;
542 
543  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
545  } else {
546  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
547  v->left_blk_sh = 3;
548  v->top_blk_sh = 0;
549  }
550 
551  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
552  v->sprite_width = avctx->coded_width;
553  v->sprite_height = avctx->coded_height;
554 
555  avctx->coded_width = avctx->width = v->output_width;
556  avctx->coded_height = avctx->height = v->output_height;
557 
558  // prevent 16.16 overflows
559  if (v->sprite_width > 1 << 14 ||
560  v->sprite_height > 1 << 14 ||
561  v->output_width > 1 << 14 ||
562  v->output_height > 1 << 14) return -1;
563 
564  if ((v->sprite_width&1) || (v->sprite_height&1)) {
565  avpriv_request_sample(avctx, "odd sprites support");
566  return AVERROR_PATCHWELCOME;
567  }
568  }
569  return 0;
570 }
571 
572 /** Close a VC1/WMV3 decoder
573  * @warning Initial try at using MpegEncContext stuff
574  */
576 {
577  VC1Context *v = avctx->priv_data;
578  int i;
579 
581 
582  for (i = 0; i < 4; i++)
583  av_freep(&v->sr_rows[i >> 1][i & 1]);
584  av_freep(&v->hrd_rate);
585  av_freep(&v->hrd_buffer);
586  ff_mpv_common_end(&v->s);
590  av_freep(&v->fieldtx_plane);
591  av_freep(&v->acpred_plane);
593  av_freep(&v->mb_type_base);
595  av_freep(&v->mv_f_base);
597  av_freep(&v->block);
598  av_freep(&v->cbp_base);
599  av_freep(&v->ttblk_base);
600  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
601  av_freep(&v->luma_mv_base);
603  return 0;
604 }
605 
606 
607 /** Decode a VC1/WMV3 frame
608  * @todo TODO: Handle VC-1 IDUs (Transport level?)
609  */
610 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
611  int *got_frame, AVPacket *avpkt)
612 {
613  const uint8_t *buf = avpkt->data;
614  int buf_size = avpkt->size, n_slices = 0, i, ret;
615  VC1Context *v = avctx->priv_data;
616  MpegEncContext *s = &v->s;
617  AVFrame *pict = data;
618  uint8_t *buf2 = NULL;
619  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
620  int mb_height, n_slices1=-1;
621  struct {
622  uint8_t *buf;
623  GetBitContext gb;
624  int mby_start;
625  } *slices = NULL, *tmp;
626 
627  v->second_field = 0;
628 
629  if(s->flags & CODEC_FLAG_LOW_DELAY)
630  s->low_delay = 1;
631 
632  /* no supplementary picture */
633  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
634  /* special case for last picture */
635  if (s->low_delay == 0 && s->next_picture_ptr) {
636  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
637  return ret;
638  s->next_picture_ptr = NULL;
639 
640  *got_frame = 1;
641  }
642 
643  return buf_size;
644  }
645 
647  if (v->profile < PROFILE_ADVANCED)
649  else
650  avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
651  }
652 
653  //for advanced profile we may need to parse and unescape data
654  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
655  int buf_size2 = 0;
656  buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
657  if (!buf2)
658  return AVERROR(ENOMEM);
659 
660  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
661  const uint8_t *start, *end, *next;
662  int size;
663 
664  next = buf;
665  for (start = buf, end = buf + buf_size; next < end; start = next) {
666  next = find_next_marker(start + 4, end);
667  size = next - start - 4;
668  if (size <= 0) continue;
669  switch (AV_RB32(start)) {
670  case VC1_CODE_FRAME:
671  if (avctx->hwaccel ||
673  buf_start = start;
674  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
675  break;
676  case VC1_CODE_FIELD: {
677  int buf_size3;
678  if (avctx->hwaccel ||
680  buf_start_second_field = start;
681  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
682  if (!tmp)
683  goto err;
684  slices = tmp;
685  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
686  if (!slices[n_slices].buf)
687  goto err;
688  buf_size3 = vc1_unescape_buffer(start + 4, size,
689  slices[n_slices].buf);
690  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
691  buf_size3 << 3);
692  /* assuming that the field marker is at the exact middle,
693  hope it's correct */
694  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
695  n_slices1 = n_slices - 1; // index of the last slice of the first field
696  n_slices++;
697  break;
698  }
699  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
700  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
701  init_get_bits(&s->gb, buf2, buf_size2 * 8);
702  ff_vc1_decode_entry_point(avctx, v, &s->gb);
703  break;
704  case VC1_CODE_SLICE: {
705  int buf_size3;
706  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
707  if (!tmp)
708  goto err;
709  slices = tmp;
710  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
711  if (!slices[n_slices].buf)
712  goto err;
713  buf_size3 = vc1_unescape_buffer(start + 4, size,
714  slices[n_slices].buf);
715  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
716  buf_size3 << 3);
717  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
718  n_slices++;
719  break;
720  }
721  }
722  }
723  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
724  const uint8_t *divider;
725  int buf_size3;
726 
727  divider = find_next_marker(buf, buf + buf_size);
728  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
729  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
730  goto err;
731  } else { // found field marker, unescape second field
732  if (avctx->hwaccel ||
734  buf_start_second_field = divider;
735  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
736  if (!tmp)
737  goto err;
738  slices = tmp;
739  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
740  if (!slices[n_slices].buf)
741  goto err;
742  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
743  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
744  buf_size3 << 3);
745  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
746  n_slices1 = n_slices - 1;
747  n_slices++;
748  }
749  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
750  } else {
751  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
752  }
753  init_get_bits(&s->gb, buf2, buf_size2*8);
754  } else
755  init_get_bits(&s->gb, buf, buf_size*8);
756 
757  if (v->res_sprite) {
758  v->new_sprite = !get_bits1(&s->gb);
759  v->two_sprites = get_bits1(&s->gb);
760  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
761  we're using the sprite compositor. These are intentionally kept separate
762  so you can get the raw sprites by using the wmv3 decoder for WMVP or
763  the vc1 one for WVP2 */
764  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
765  if (v->new_sprite) {
766  // switch AVCodecContext parameters to those of the sprites
767  avctx->width = avctx->coded_width = v->sprite_width;
768  avctx->height = avctx->coded_height = v->sprite_height;
769  } else {
770  goto image;
771  }
772  }
773  }
774 
775  if (s->context_initialized &&
776  (s->width != avctx->coded_width ||
777  s->height != avctx->coded_height)) {
778  ff_vc1_decode_end(avctx);
779  }
780 
781  if (!s->context_initialized) {
782  if (ff_msmpeg4_decode_init(avctx) < 0)
783  goto err;
784  if (ff_vc1_decode_init_alloc_tables(v) < 0) {
786  goto err;
787  }
788 
789  s->low_delay = !avctx->has_b_frames || v->res_sprite;
790 
791  if (v->profile == PROFILE_ADVANCED) {
792  if(avctx->coded_width<=1 || avctx->coded_height<=1)
793  goto err;
794  s->h_edge_pos = avctx->coded_width;
795  s->v_edge_pos = avctx->coded_height;
796  }
797  }
798 
799  // do parse frame header
800  v->pic_header_flag = 0;
801  v->first_pic_header_flag = 1;
802  if (v->profile < PROFILE_ADVANCED) {
803  if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
804  goto err;
805  }
806  } else {
807  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
808  goto err;
809  }
810  }
811  v->first_pic_header_flag = 0;
812 
813  if (avctx->debug & FF_DEBUG_PICT_INFO)
814  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
815 
816  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
817  && s->pict_type != AV_PICTURE_TYPE_I) {
818  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
819  goto err;
820  }
821 
822  if ((s->mb_height >> v->field_mode) == 0) {
823  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
824  goto err;
825  }
826 
827  // for skipping the frame
830 
831  /* skip B-frames if we don't have reference frames */
832  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
833  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
834  goto end;
835  }
836  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
838  avctx->skip_frame >= AVDISCARD_ALL) {
839  goto end;
840  }
841 
842  if (s->next_p_frame_damaged) {
843  if (s->pict_type == AV_PICTURE_TYPE_B)
844  goto end;
845  else
846  s->next_p_frame_damaged = 0;
847  }
848 
849  if (ff_mpv_frame_start(s, avctx) < 0) {
850  goto err;
851  }
852 
856 
857  // process pulldown flags
859  // Pulldown flags are only valid when 'broadcast' has been set.
860  // So ticks_per_frame will be 2
861  if (v->rff) {
862  // repeat field
864  } else if (v->rptfrm) {
865  // repeat frames
866  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
867  }
868 
871 
872  if ((CONFIG_VC1_VDPAU_DECODER)
874  if (v->field_mode && buf_start_second_field) {
875  ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
876  ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
877  } else {
878  ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
879  }
880  } else if (avctx->hwaccel) {
881  if (v->field_mode && buf_start_second_field) {
882  // decode first field
884  if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
885  goto err;
886  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
887  goto err;
888  if (avctx->hwaccel->end_frame(avctx) < 0)
889  goto err;
890 
891  // decode second field
892  s->gb = slices[n_slices1 + 1].gb;
894  v->second_field = 1;
895  v->pic_header_flag = 0;
896  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
897  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
898  goto err;
899  }
901 
902  if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
903  goto err;
904  if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
905  goto err;
906  if (avctx->hwaccel->end_frame(avctx) < 0)
907  goto err;
908  } else {
910  if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
911  goto err;
912  if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
913  goto err;
914  if (avctx->hwaccel->end_frame(avctx) < 0)
915  goto err;
916  }
917  } else {
918  int header_ret = 0;
919 
921 
922  v->bits = buf_size * 8;
923  v->end_mb_x = s->mb_width;
924  if (v->field_mode) {
925  s->current_picture.f->linesize[0] <<= 1;
926  s->current_picture.f->linesize[1] <<= 1;
927  s->current_picture.f->linesize[2] <<= 1;
928  s->linesize <<= 1;
929  s->uvlinesize <<= 1;
930  }
931  mb_height = s->mb_height >> v->field_mode;
932 
933  av_assert0 (mb_height > 0);
934 
935  for (i = 0; i <= n_slices; i++) {
936  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
937  if (v->field_mode <= 0) {
938  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
939  "picture boundary (%d >= %d)\n", i,
940  slices[i - 1].mby_start, mb_height);
941  continue;
942  }
943  v->second_field = 1;
944  av_assert0((s->mb_height & 1) == 0);
945  v->blocks_off = s->b8_stride * (s->mb_height&~1);
946  v->mb_off = s->mb_stride * s->mb_height >> 1;
947  } else {
948  v->second_field = 0;
949  v->blocks_off = 0;
950  v->mb_off = 0;
951  }
952  if (i) {
953  v->pic_header_flag = 0;
954  if (v->field_mode && i == n_slices1 + 2) {
955  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
956  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
957  if (avctx->err_recognition & AV_EF_EXPLODE)
958  goto err;
959  continue;
960  }
961  } else if (get_bits1(&s->gb)) {
962  v->pic_header_flag = 1;
963  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
964  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
965  if (avctx->err_recognition & AV_EF_EXPLODE)
966  goto err;
967  continue;
968  }
969  }
970  }
971  if (header_ret < 0)
972  continue;
973  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
974  if (!v->field_mode || v->second_field)
975  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
976  else {
977  if (i >= n_slices) {
978  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
979  continue;
980  }
981  s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
982  }
983  if (s->end_mb_y <= s->start_mb_y) {
984  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
985  continue;
986  }
987  if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
988  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
989  continue;
990  }
992  if (i != n_slices)
993  s->gb = slices[i].gb;
994  }
995  if (v->field_mode) {
996  v->second_field = 0;
997  s->current_picture.f->linesize[0] >>= 1;
998  s->current_picture.f->linesize[1] >>= 1;
999  s->current_picture.f->linesize[2] >>= 1;
1000  s->linesize >>= 1;
1001  s->uvlinesize >>= 1;
1003  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1004  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1005  }
1006  }
1007  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1008  get_bits_count(&s->gb), s->gb.size_in_bits);
1009 // if (get_bits_count(&s->gb) > buf_size * 8)
1010 // return -1;
1012  goto err;
1013  if (!v->field_mode)
1014  ff_er_frame_end(&s->er);
1015  }
1016 
1017  ff_mpv_frame_end(s);
1018 
1019  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1020 image:
1021  avctx->width = avctx->coded_width = v->output_width;
1022  avctx->height = avctx->coded_height = v->output_height;
1023  if (avctx->skip_frame >= AVDISCARD_NONREF)
1024  goto end;
1025 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1026  if (vc1_decode_sprites(v, &s->gb))
1027  goto err;
1028 #endif
1029  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1030  goto err;
1031  *got_frame = 1;
1032  } else {
1033  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1034  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1035  goto err;
1037  *got_frame = 1;
1038  } else if (s->last_picture_ptr) {
1039  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1040  goto err;
1042  *got_frame = 1;
1043  }
1044  }
1045 
1046 end:
1047  av_free(buf2);
1048  for (i = 0; i < n_slices; i++)
1049  av_free(slices[i].buf);
1050  av_free(slices);
1051  return buf_size;
1052 
1053 err:
1054  av_free(buf2);
1055  for (i = 0; i < n_slices; i++)
1056  av_free(slices[i].buf);
1057  av_free(slices);
1058  return -1;
1059 }
1060 
1061 
1062 static const AVProfile profiles[] = {
1063  { FF_PROFILE_VC1_SIMPLE, "Simple" },
1064  { FF_PROFILE_VC1_MAIN, "Main" },
1065  { FF_PROFILE_VC1_COMPLEX, "Complex" },
1066  { FF_PROFILE_VC1_ADVANCED, "Advanced" },
1067  { FF_PROFILE_UNKNOWN },
1068 };
1069 
1071 #if CONFIG_VC1_DXVA2_HWACCEL
1073 #endif
1074 #if CONFIG_VC1_VAAPI_HWACCEL
1076 #endif
1077 #if CONFIG_VC1_VDPAU_HWACCEL
1079 #endif
1082 };
1083 
1085  .name = "vc1",
1086  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1087  .type = AVMEDIA_TYPE_VIDEO,
1088  .id = AV_CODEC_ID_VC1,
1089  .priv_data_size = sizeof(VC1Context),
1090  .init = vc1_decode_init,
1091  .close = ff_vc1_decode_end,
1093  .flush = ff_mpeg_flush,
1094  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1095  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1096  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1097 };
1098 
1099 #if CONFIG_WMV3_DECODER
1100 AVCodec ff_wmv3_decoder = {
1101  .name = "wmv3",
1102  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1103  .type = AVMEDIA_TYPE_VIDEO,
1104  .id = AV_CODEC_ID_WMV3,
1105  .priv_data_size = sizeof(VC1Context),
1106  .init = vc1_decode_init,
1107  .close = ff_vc1_decode_end,
1109  .flush = ff_mpeg_flush,
1110  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1111  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1112  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1113 };
1114 #endif
1115 
1116 #if CONFIG_WMV3_VDPAU_DECODER
1117 AVCodec ff_wmv3_vdpau_decoder = {
1118  .name = "wmv3_vdpau",
1119  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1120  .type = AVMEDIA_TYPE_VIDEO,
1121  .id = AV_CODEC_ID_WMV3,
1122  .priv_data_size = sizeof(VC1Context),
1123  .init = vc1_decode_init,
1124  .close = ff_vc1_decode_end,
1127  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1128  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1129 };
1130 #endif
1131 
1132 #if CONFIG_VC1_VDPAU_DECODER
1133 AVCodec ff_vc1_vdpau_decoder = {
1134  .name = "vc1_vdpau",
1135  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1136  .type = AVMEDIA_TYPE_VIDEO,
1137  .id = AV_CODEC_ID_VC1,
1138  .priv_data_size = sizeof(VC1Context),
1139  .init = vc1_decode_init,
1140  .close = ff_vc1_decode_end,
1143  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1144  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1145 };
1146 #endif
1147 
1148 #if CONFIG_WMV3IMAGE_DECODER
1149 AVCodec ff_wmv3image_decoder = {
1150  .name = "wmv3image",
1151  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1152  .type = AVMEDIA_TYPE_VIDEO,
1153  .id = AV_CODEC_ID_WMV3IMAGE,
1154  .priv_data_size = sizeof(VC1Context),
1155  .init = vc1_decode_init,
1156  .close = ff_vc1_decode_end,
1158  .capabilities = CODEC_CAP_DR1,
1159  .flush = vc1_sprite_flush,
1160  .pix_fmts = (const enum AVPixelFormat[]) {
1163  },
1164 };
1165 #endif
1166 
1167 #if CONFIG_VC1IMAGE_DECODER
1168 AVCodec ff_vc1image_decoder = {
1169  .name = "vc1image",
1170  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1171  .type = AVMEDIA_TYPE_VIDEO,
1172  .id = AV_CODEC_ID_VC1IMAGE,
1173  .priv_data_size = sizeof(VC1Context),
1174  .init = vc1_decode_init,
1175  .close = ff_vc1_decode_end,
1177  .capabilities = CODEC_CAP_DR1,
1178  .flush = vc1_sprite_flush,
1179  .pix_fmts = (const enum AVPixelFormat[]) {
1182  },
1183 };
1184 #endif