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 "msmpeg4.h"
36 #include "msmpeg4data.h"
37 #include "profiles.h"
38 #include "vc1.h"
39 #include "vc1data.h"
40 #include "vdpau_compat.h"
41 #include "libavutil/avassert.h"
42 
43 
44 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
45 
46 typedef struct SpriteData {
47  /**
48  * Transform coefficients for both sprites in 16.16 fixed point format,
49  * in the order they appear in the bitstream:
50  * x scale
51  * rotation 1 (unused)
52  * x offset
53  * rotation 2 (unused)
54  * y scale
55  * y offset
56  * alpha
57  */
58  int coefs[2][7];
59 
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
63 } SpriteData;
64 
65 static inline int get_fp_val(GetBitContext* gb)
66 {
67  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
68 }
69 
70 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
71 {
72  c[1] = c[3] = 0;
73 
74  switch (get_bits(gb, 2)) {
75  case 0:
76  c[0] = 1 << 16;
77  c[2] = get_fp_val(gb);
78  c[4] = 1 << 16;
79  break;
80  case 1:
81  c[0] = c[4] = get_fp_val(gb);
82  c[2] = get_fp_val(gb);
83  break;
84  case 2:
85  c[0] = get_fp_val(gb);
86  c[2] = get_fp_val(gb);
87  c[4] = get_fp_val(gb);
88  break;
89  case 3:
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);
95  break;
96  }
97  c[5] = get_fp_val(gb);
98  if (get_bits1(gb))
99  c[6] = get_fp_val(gb);
100  else
101  c[6] = 1 << 16;
102 }
103 
104 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
105 {
106  AVCodecContext *avctx = v->s.avctx;
107  int sprite, i;
108 
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");
119  }
120 
121  skip_bits(gb, 2);
122  if (sd->effect_type = get_bits_long(gb, 30)) {
123  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
124  case 7:
125  vc1_sprite_parse_transform(gb, sd->effect_params1);
126  break;
127  case 14:
128  vc1_sprite_parse_transform(gb, sd->effect_params1);
129  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
130  break;
131  default:
132  for (i = 0; i < sd->effect_pcount1; i++)
133  sd->effect_params1[i] = get_fp_val(gb);
134  }
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");
143  }
144 
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) {
150  i = -1;
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));
157  }
158  av_log(avctx, AV_LOG_DEBUG, "\n");
159  }
160  }
161  if (sd->effect_flag = get_bits1(gb))
162  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
163 
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;
168  }
169  if (get_bits_count(gb) < gb->size_in_bits - 8)
170  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
171 
172  return 0;
173 }
174 
175 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
176 {
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;
181  int ysub[2];
182  MpegEncContext *s = &v->s;
183 
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);
189 
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);
192  }
193  alpha = av_clip_uint16(sd->coefs[1][6]);
194 
195  for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
196  int width = v->output_width>>!!plane;
197 
198  for (row = 0; row < v->output_height>>!!plane; row++) {
199  uint8_t *dst = v->sprite_output_frame->data[plane] +
201 
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;
207  int next_line;
208  ysub[sprite] = ycoord & 0xFFFF;
209  if (sprite) {
210  iplane = s->last_picture.f->data[plane];
211  iline = s->last_picture.f->linesize[plane];
212  }
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;
216  if (ysub[sprite])
217  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
218  } else {
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]);
223  } else {
224  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
225  sr_cache[sprite][0] = yline;
226  }
227  }
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;
233  }
234  src_h[sprite][0] = v->sr_rows[sprite][0];
235  src_h[sprite][1] = v->sr_rows[sprite][1];
236  }
237  }
238 
239  if (!v->two_sprites) {
240  if (ysub[0]) {
241  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
242  } else {
243  memcpy(dst, src_h[0][0], width);
244  }
245  } else {
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);
255  } else {
256  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
257  }
258  }
259  }
260 
261  if (!plane) {
262  for (i = 0; i <= v->two_sprites; i++) {
263  xoff[i] >>= 1;
264  yoff[i] >>= 1;
265  }
266  }
267 
268  }
269 }
270 
271 
272 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
273 {
274  int ret;
275  MpegEncContext *s = &v->s;
276  AVCodecContext *avctx = s->avctx;
277  SpriteData sd;
278 
279  memset(&sd, 0, sizeof(sd));
280 
281  ret = vc1_parse_sprites(v, gb, &sd);
282  if (ret < 0)
283  return ret;
284 
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;
288  }
289 
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");
292  v->two_sprites = 0;
293  }
294 
296  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
297  return ret;
298 
299  vc1_draw_sprites(v, &sd);
300 
301  return 0;
302 }
303 
304 static void vc1_sprite_flush(AVCodecContext *avctx)
305 {
306  VC1Context *v = avctx->priv_data;
307  MpegEncContext *s = &v->s;
308  AVFrame *f = s->current_picture.f;
309  int plane, i;
310 
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. */
314 
315  if (f && f->data[0])
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]);
320 }
321 
322 #endif
323 
325 {
326  MpegEncContext *s = &v->s;
327  int i;
328  int mb_height = FFALIGN(s->mb_height, 2);
329 
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 
338  v->n_allocated_blks = s->mb_width + 2;
339  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
340  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
341  v->cbp = v->cbp_base + s->mb_stride;
342  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
343  v->ttblk = v->ttblk_base + s->mb_stride;
344  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
345  v->is_intra = v->is_intra_base + s->mb_stride;
346  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
347  v->luma_mv = v->luma_mv_base + s->mb_stride;
348 
349  /* allocate block type info in that way so it could be used with s->block_index[] */
350  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
351  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
352  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
353  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
354 
355  /* allocate memory to store block level MV info */
356  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
357  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
358  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
359  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
360  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
361  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
362  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
363  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
364 
365  /* Init coded blocks info */
366  if (v->profile == PROFILE_ADVANCED) {
367 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
368 // return -1;
369 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
370 // return -1;
371  }
372 
373  ff_intrax8_common_init(&v->x8,s);
374 
376  for (i = 0; i < 4; i++)
377  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
378  return AVERROR(ENOMEM);
379  }
380 
381  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
382  !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
383  !v->mb_type_base) {
386  av_freep(&v->acpred_plane);
388  av_freep(&v->block);
389  av_freep(&v->cbp_base);
390  av_freep(&v->ttblk_base);
391  av_freep(&v->is_intra_base);
392  av_freep(&v->luma_mv_base);
393  av_freep(&v->mb_type_base);
394  return AVERROR(ENOMEM);
395  }
396 
397  return 0;
398 }
399 
401 {
402  int i;
403  for (i = 0; i < 64; i++) {
404 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
405  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
406  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
407  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
408  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
410  }
411  v->left_blk_sh = 0;
412  v->top_blk_sh = 3;
413 }
414 
415 /** Initialize a VC1/WMV3 decoder
416  * @todo TODO: Handle VC-1 IDUs (Transport level?)
417  * @todo TODO: Decypher remaining bits in extra_data
418  */
420 {
421  VC1Context *v = avctx->priv_data;
422  MpegEncContext *s = &v->s;
423  GetBitContext gb;
424  int ret;
425 
426  /* save the container output size for WMImage */
427  v->output_width = avctx->width;
428  v->output_height = avctx->height;
429 
430  if (!avctx->extradata_size || !avctx->extradata)
431  return -1;
432  v->s.avctx = avctx;
433 
434  if ((ret = ff_vc1_init_common(v)) < 0)
435  return ret;
436 
437  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
438  int count = 0;
439 
440  // looks like WMV3 has a sequence header stored in the extradata
441  // advanced sequence header may be before the first frame
442  // the last byte of the extradata is a version number, 1 for the
443  // samples we can decode
444 
445  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
446 
447  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
448  return ret;
449 
450  count = avctx->extradata_size*8 - get_bits_count(&gb);
451  if (count > 0) {
452  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
453  count, get_bits_long(&gb, FFMIN(count, 32)));
454  } else if (count < 0) {
455  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
456  }
457  } else { // VC1/WVC1/WVP2
458  const uint8_t *start = avctx->extradata;
459  uint8_t *end = avctx->extradata + avctx->extradata_size;
460  const uint8_t *next;
461  int size, buf2_size;
462  uint8_t *buf2 = NULL;
463  int seq_initialized = 0, ep_initialized = 0;
464 
465  if (avctx->extradata_size < 16) {
466  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
467  return -1;
468  }
469 
471  if (!buf2)
472  return AVERROR(ENOMEM);
473 
474  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
475  next = start;
476  for (; next < end; start = next) {
477  next = find_next_marker(start + 4, end);
478  size = next - start - 4;
479  if (size <= 0)
480  continue;
481  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
482  init_get_bits(&gb, buf2, buf2_size * 8);
483  switch (AV_RB32(start)) {
484  case VC1_CODE_SEQHDR:
485  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
486  av_free(buf2);
487  return ret;
488  }
489  seq_initialized = 1;
490  break;
491  case VC1_CODE_ENTRYPOINT:
492  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
493  av_free(buf2);
494  return ret;
495  }
496  ep_initialized = 1;
497  break;
498  }
499  }
500  av_free(buf2);
501  if (!seq_initialized || !ep_initialized) {
502  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
503  return -1;
504  }
505  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
506  }
507 
508  avctx->profile = v->profile;
509  if (v->profile == PROFILE_ADVANCED)
510  avctx->level = v->level;
511 
512  if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
513  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
514  else {
515  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
516  if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
517  avctx->color_range = AVCOL_RANGE_MPEG;
518  }
519 
520  // ensure static VLC tables are initialized
521  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
522  return ret;
523  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
524  return ret;
525  // Hack to ensure the above functions will be called
526  // again once we know all necessary settings.
527  // That this is necessary might indicate a bug.
528  ff_vc1_decode_end(avctx);
529 
530  ff_blockdsp_init(&s->bdsp, avctx);
532  ff_qpeldsp_init(&s->qdsp);
533 
534  // Must happen after calling ff_vc1_decode_end
535  // to avoid de-allocating the sprite_output_frame
537  if (!v->sprite_output_frame)
538  return AVERROR(ENOMEM);
539 
540  avctx->has_b_frames = !!avctx->max_b_frames;
541 
542  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
543  avctx->color_primaries = v->color_prim;
544  if (v->transfer_char == 1 || v->transfer_char == 7)
545  avctx->color_trc = v->transfer_char;
546  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
547  avctx->colorspace = v->matrix_coef;
548 
549  s->mb_width = (avctx->coded_width + 15) >> 4;
550  s->mb_height = (avctx->coded_height + 15) >> 4;
551 
552  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
554  } else {
555  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
556  v->left_blk_sh = 3;
557  v->top_blk_sh = 0;
558  }
559 
560  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
561  v->sprite_width = avctx->coded_width;
562  v->sprite_height = avctx->coded_height;
563 
564  avctx->coded_width = avctx->width = v->output_width;
565  avctx->coded_height = avctx->height = v->output_height;
566 
567  // prevent 16.16 overflows
568  if (v->sprite_width > 1 << 14 ||
569  v->sprite_height > 1 << 14 ||
570  v->output_width > 1 << 14 ||
571  v->output_height > 1 << 14) return -1;
572 
573  if ((v->sprite_width&1) || (v->sprite_height&1)) {
574  avpriv_request_sample(avctx, "odd sprites support");
575  return AVERROR_PATCHWELCOME;
576  }
577  }
578  return 0;
579 }
580 
581 /** Close a VC1/WMV3 decoder
582  * @warning Initial try at using MpegEncContext stuff
583  */
585 {
586  VC1Context *v = avctx->priv_data;
587  int i;
588 
590 
591  for (i = 0; i < 4; i++)
592  av_freep(&v->sr_rows[i >> 1][i & 1]);
593  av_freep(&v->hrd_rate);
594  av_freep(&v->hrd_buffer);
595  ff_mpv_common_end(&v->s);
599  av_freep(&v->fieldtx_plane);
600  av_freep(&v->acpred_plane);
602  av_freep(&v->mb_type_base);
604  av_freep(&v->mv_f_base);
606  av_freep(&v->block);
607  av_freep(&v->cbp_base);
608  av_freep(&v->ttblk_base);
609  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
610  av_freep(&v->luma_mv_base);
612  return 0;
613 }
614 
615 
616 /** Decode a VC1/WMV3 frame
617  * @todo TODO: Handle VC-1 IDUs (Transport level?)
618  */
619 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
620  int *got_frame, AVPacket *avpkt)
621 {
622  const uint8_t *buf = avpkt->data;
623  int buf_size = avpkt->size, n_slices = 0, i, ret;
624  VC1Context *v = avctx->priv_data;
625  MpegEncContext *s = &v->s;
626  AVFrame *pict = data;
627  uint8_t *buf2 = NULL;
628  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
629  int mb_height, n_slices1=-1;
630  struct {
631  uint8_t *buf;
632  GetBitContext gb;
633  int mby_start;
634  } *slices = NULL, *tmp;
635 
636  v->second_field = 0;
637 
639  s->low_delay = 1;
640 
641  /* no supplementary picture */
642  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
643  /* special case for last picture */
644  if (s->low_delay == 0 && s->next_picture_ptr) {
645  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
646  return ret;
647  s->next_picture_ptr = NULL;
648 
649  *got_frame = 1;
650  }
651 
652  return buf_size;
653  }
654 
655 #if FF_API_CAP_VDPAU
657  if (v->profile < PROFILE_ADVANCED)
659  else
660  avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
661  }
662 #endif
663 
664  //for advanced profile we may need to parse and unescape data
665  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
666  int buf_size2 = 0;
667  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
668  if (!buf2)
669  return AVERROR(ENOMEM);
670 
671  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
672  const uint8_t *start, *end, *next;
673  int size;
674 
675  next = buf;
676  for (start = buf, end = buf + buf_size; next < end; start = next) {
677  next = find_next_marker(start + 4, end);
678  size = next - start - 4;
679  if (size <= 0) continue;
680  switch (AV_RB32(start)) {
681  case VC1_CODE_FRAME:
682  if (avctx->hwaccel
685 #endif
686  )
687  buf_start = start;
688  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
689  break;
690  case VC1_CODE_FIELD: {
691  int buf_size3;
692  if (avctx->hwaccel
695 #endif
696  )
697  buf_start_second_field = start;
698  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
699  if (!tmp) {
700  ret = AVERROR(ENOMEM);
701  goto err;
702  }
703  slices = tmp;
704  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
705  if (!slices[n_slices].buf) {
706  ret = AVERROR(ENOMEM);
707  goto err;
708  }
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,
712  buf_size3 << 3);
713  /* assuming that the field marker is at the exact middle,
714  hope it's correct */
715  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
716  n_slices1 = n_slices - 1; // index of the last slice of the first field
717  n_slices++;
718  break;
719  }
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);
724  break;
725  case VC1_CODE_SLICE: {
726  int buf_size3;
727  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
728  if (!tmp) {
729  ret = AVERROR(ENOMEM);
730  goto err;
731  }
732  slices = tmp;
733  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
734  if (!slices[n_slices].buf) {
735  ret = AVERROR(ENOMEM);
736  goto err;
737  }
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,
741  buf_size3 << 3);
742  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
743  n_slices++;
744  break;
745  }
746  }
747  }
748  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
749  const uint8_t *divider;
750  int buf_size3;
751 
752  divider = find_next_marker(buf, buf + buf_size);
753  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
754  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
755  ret = AVERROR_INVALIDDATA;
756  goto err;
757  } else { // found field marker, unescape second field
758  if (avctx->hwaccel
761 #endif
762  )
763  buf_start_second_field = divider;
764  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
765  if (!tmp) {
766  ret = AVERROR(ENOMEM);
767  goto err;
768  }
769  slices = tmp;
770  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
771  if (!slices[n_slices].buf) {
772  ret = AVERROR(ENOMEM);
773  goto err;
774  }
775  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
776  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
777  buf_size3 << 3);
778  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
779  n_slices1 = n_slices - 1;
780  n_slices++;
781  }
782  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
783  } else {
784  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
785  }
786  init_get_bits(&s->gb, buf2, buf_size2*8);
787  } else
788  init_get_bits(&s->gb, buf, buf_size*8);
789 
790  if (v->res_sprite) {
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) {
798  if (v->new_sprite) {
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;
802  } else {
803  goto image;
804  }
805  }
806  }
807 
808  if (s->context_initialized &&
809  (s->width != avctx->coded_width ||
810  s->height != avctx->coded_height)) {
811  ff_vc1_decode_end(avctx);
812  }
813 
814  if (!s->context_initialized) {
815  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
816  goto err;
817  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
819  goto err;
820  }
821 
822  s->low_delay = !avctx->has_b_frames || v->res_sprite;
823 
824  if (v->profile == PROFILE_ADVANCED) {
825  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
826  ret = AVERROR_INVALIDDATA;
827  goto err;
828  }
829  s->h_edge_pos = avctx->coded_width;
830  s->v_edge_pos = avctx->coded_height;
831  }
832  }
833 
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) {
839  goto err;
840  }
841  } else {
842  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
843  goto err;
844  }
845  }
846  v->first_pic_header_flag = 0;
847 
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));
850 
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;
855  goto err;
856  }
857 
858  if ((s->mb_height >> v->field_mode) == 0) {
859  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
860  ret = AVERROR_INVALIDDATA;
861  goto err;
862  }
863 
864  // for skipping the frame
867 
868  /* skip B-frames if we don't have reference frames */
869  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
870  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
871  goto end;
872  }
873  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
875  avctx->skip_frame >= AVDISCARD_ALL) {
876  goto end;
877  }
878 
879  if (s->next_p_frame_damaged) {
880  if (s->pict_type == AV_PICTURE_TYPE_B)
881  goto end;
882  else
883  s->next_p_frame_damaged = 0;
884  }
885 
886  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
887  goto err;
888  }
889 
893 
894  // process pulldown flags
896  // Pulldown flags are only valid when 'broadcast' has been set.
897  // So ticks_per_frame will be 2
898  if (v->rff) {
899  // repeat field
901  } else if (v->rptfrm) {
902  // repeat frames
903  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
904  }
905 
908 
909 #if FF_API_CAP_VDPAU
910  if ((CONFIG_VC1_VDPAU_DECODER)
912  if (v->field_mode && buf_start_second_field) {
913  ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
914  ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
915  } else {
916  ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
917  }
918  } else
919 #endif
920  if (avctx->hwaccel) {
921  if (v->field_mode && buf_start_second_field) {
922  // decode first field
924  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
925  goto err;
926  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
927  goto err;
928  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
929  goto err;
930 
931  // decode second field
932  s->gb = slices[n_slices1 + 1].gb;
934  v->second_field = 1;
935  v->pic_header_flag = 0;
936  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
937  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
938  ret = AVERROR_INVALIDDATA;
939  goto err;
940  }
942 
943  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
944  goto err;
945  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
946  goto err;
947  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
948  goto err;
949  } else {
951  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
952  goto err;
953  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
954  goto err;
955  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
956  goto err;
957  }
958  } else {
959  int header_ret = 0;
960 
962 
963  v->bits = buf_size * 8;
964  v->end_mb_x = s->mb_width;
965  if (v->field_mode) {
966  s->current_picture.f->linesize[0] <<= 1;
967  s->current_picture.f->linesize[1] <<= 1;
968  s->current_picture.f->linesize[2] <<= 1;
969  s->linesize <<= 1;
970  s->uvlinesize <<= 1;
971  }
972  mb_height = s->mb_height >> v->field_mode;
973 
974  av_assert0 (mb_height > 0);
975 
976  for (i = 0; i <= n_slices; i++) {
977  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
978  if (v->field_mode <= 0) {
979  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
980  "picture boundary (%d >= %d)\n", i,
981  slices[i - 1].mby_start, mb_height);
982  continue;
983  }
984  v->second_field = 1;
985  av_assert0((s->mb_height & 1) == 0);
986  v->blocks_off = s->b8_stride * (s->mb_height&~1);
987  v->mb_off = s->mb_stride * s->mb_height >> 1;
988  } else {
989  v->second_field = 0;
990  v->blocks_off = 0;
991  v->mb_off = 0;
992  }
993  if (i) {
994  v->pic_header_flag = 0;
995  if (v->field_mode && i == n_slices1 + 2) {
996  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
997  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
998  ret = AVERROR_INVALIDDATA;
999  if (avctx->err_recognition & AV_EF_EXPLODE)
1000  goto err;
1001  continue;
1002  }
1003  } else if (get_bits1(&s->gb)) {
1004  v->pic_header_flag = 1;
1005  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1006  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1007  ret = AVERROR_INVALIDDATA;
1008  if (avctx->err_recognition & AV_EF_EXPLODE)
1009  goto err;
1010  continue;
1011  }
1012  }
1013  }
1014  if (header_ret < 0)
1015  continue;
1016  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1017  if (!v->field_mode || v->second_field)
1018  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1019  else {
1020  if (i >= n_slices) {
1021  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1022  continue;
1023  }
1024  s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1025  }
1026  if (s->end_mb_y <= s->start_mb_y) {
1027  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1028  continue;
1029  }
1030  if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1031  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1032  continue;
1033  }
1035  if (i != n_slices)
1036  s->gb = slices[i].gb;
1037  }
1038  if (v->field_mode) {
1039  v->second_field = 0;
1040  s->current_picture.f->linesize[0] >>= 1;
1041  s->current_picture.f->linesize[1] >>= 1;
1042  s->current_picture.f->linesize[2] >>= 1;
1043  s->linesize >>= 1;
1044  s->uvlinesize >>= 1;
1046  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1047  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1048  }
1049  }
1050  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1051  get_bits_count(&s->gb), s->gb.size_in_bits);
1052 // if (get_bits_count(&s->gb) > buf_size * 8)
1053 // return -1;
1054  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1055  ret = AVERROR_INVALIDDATA;
1056  goto err;
1057  }
1058  if (!v->field_mode)
1059  ff_er_frame_end(&s->er);
1060  }
1061 
1062  ff_mpv_frame_end(s);
1063 
1064  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1065 image:
1066  avctx->width = avctx->coded_width = v->output_width;
1067  avctx->height = avctx->coded_height = v->output_height;
1068  if (avctx->skip_frame >= AVDISCARD_NONREF)
1069  goto end;
1070 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1071  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1072  goto err;
1073 #endif
1074  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1075  goto err;
1076  *got_frame = 1;
1077  } else {
1078  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1079  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1080  goto err;
1082  *got_frame = 1;
1083  } else if (s->last_picture_ptr) {
1084  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1085  goto err;
1087  *got_frame = 1;
1088  }
1089  }
1090 
1091 end:
1092  av_free(buf2);
1093  for (i = 0; i < n_slices; i++)
1094  av_free(slices[i].buf);
1095  av_free(slices);
1096  return buf_size;
1097 
1098 err:
1099  av_free(buf2);
1100  for (i = 0; i < n_slices; i++)
1101  av_free(slices[i].buf);
1102  av_free(slices);
1103  return ret;
1104 }
1105 
1106 
1108 #if CONFIG_VC1_DXVA2_HWACCEL
1110 #endif
1111 #if CONFIG_VC1_D3D11VA_HWACCEL
1113 #endif
1114 #if CONFIG_VC1_VAAPI_HWACCEL
1116 #endif
1117 #if CONFIG_VC1_VDPAU_HWACCEL
1119 #endif
1122 };
1123 
1125  .name = "vc1",
1126  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1127  .type = AVMEDIA_TYPE_VIDEO,
1128  .id = AV_CODEC_ID_VC1,
1129  .priv_data_size = sizeof(VC1Context),
1130  .init = vc1_decode_init,
1131  .close = ff_vc1_decode_end,
1133  .flush = ff_mpeg_flush,
1134  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1135  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1137 };
1138 
1139 #if CONFIG_WMV3_DECODER
1140 AVCodec ff_wmv3_decoder = {
1141  .name = "wmv3",
1142  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1143  .type = AVMEDIA_TYPE_VIDEO,
1144  .id = AV_CODEC_ID_WMV3,
1145  .priv_data_size = sizeof(VC1Context),
1146  .init = vc1_decode_init,
1147  .close = ff_vc1_decode_end,
1149  .flush = ff_mpeg_flush,
1150  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1151  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1153 };
1154 #endif
1155 
1156 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1157 AVCodec ff_wmv3_vdpau_decoder = {
1158  .name = "wmv3_vdpau",
1159  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1160  .type = AVMEDIA_TYPE_VIDEO,
1161  .id = AV_CODEC_ID_WMV3,
1162  .priv_data_size = sizeof(VC1Context),
1163  .init = vc1_decode_init,
1164  .close = ff_vc1_decode_end,
1169 };
1170 #endif
1171 
1172 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1173 AVCodec ff_vc1_vdpau_decoder = {
1174  .name = "vc1_vdpau",
1175  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1176  .type = AVMEDIA_TYPE_VIDEO,
1177  .id = AV_CODEC_ID_VC1,
1178  .priv_data_size = sizeof(VC1Context),
1179  .init = vc1_decode_init,
1180  .close = ff_vc1_decode_end,
1185 };
1186 #endif
1187 
1188 #if CONFIG_WMV3IMAGE_DECODER
1189 AVCodec ff_wmv3image_decoder = {
1190  .name = "wmv3image",
1191  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1192  .type = AVMEDIA_TYPE_VIDEO,
1193  .id = AV_CODEC_ID_WMV3IMAGE,
1194  .priv_data_size = sizeof(VC1Context),
1195  .init = vc1_decode_init,
1196  .close = ff_vc1_decode_end,
1198  .capabilities = AV_CODEC_CAP_DR1,
1199  .flush = vc1_sprite_flush,
1200  .pix_fmts = (const enum AVPixelFormat[]) {
1203  },
1204 };
1205 #endif
1206 
1207 #if CONFIG_VC1IMAGE_DECODER
1208 AVCodec ff_vc1image_decoder = {
1209  .name = "vc1image",
1210  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1211  .type = AVMEDIA_TYPE_VIDEO,
1212  .id = AV_CODEC_ID_VC1IMAGE,
1213  .priv_data_size = sizeof(VC1Context),
1214  .init = vc1_decode_init,
1215  .close = ff_vc1_decode_end,
1217  .capabilities = AV_CODEC_CAP_DR1,
1218  .flush = vc1_sprite_flush,
1219  .pix_fmts = (const enum AVPixelFormat[]) {
1222  },
1223 };
1224 #endif
int color_prim
8bits, chroma coordinates of the color primaries
Definition: vc1.h:206
in the bitstream is reported as 00b
Definition: vc1.h:149
int plane
Definition: avisynth_c.h:291
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1541
discard all frames except keyframes
Definition: avcodec.h:687
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:3560
BI type.
Definition: avutil.h:272
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:74
int p_frame_skipped
Definition: vc1.h:380
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
The VC1 Context.
Definition: vc1.h:173
This structure describes decoded (raw) audio or video data.
Definition: frame.h:181
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:150
static void flush(AVCodecContext *avctx)
uint8_t * mv_f_base
Definition: vc1.h:350
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1726
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:288
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:151
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1810
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:584
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:129
void ff_er_frame_end(ERContext *s)
void(* sprite_v_double_onescale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset1, const uint8_t *src2a, int alpha, int width)
Definition: vc1dsp.h:71
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2262
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:307
int size
Definition: avcodec.h:1468
int transfer_char
8bits, Opto-electronic transfer characteristics
Definition: vc1.h:207
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:79
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1752
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1107
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition: vc1.h:239
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
mpegvideo header.
IntraX8Context x8
Definition: vc1.h:175
uint8_t * mb_type_base
Definition: vc1.h:264
discard all
Definition: avcodec.h:688
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:350
int sprite_height
Definition: vc1.h:376
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:393
int profile
profile
Definition: avcodec.h:3028
QpelDSPContext qdsp
Definition: mpegvideo.h:232
AVCodec.
Definition: avcodec.h:3392
uint8_t rff
Definition: vc1.h:311
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3139
int bits
Definition: vc1.h:179
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2843
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:881
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:321
VC-1 tables.
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int matrix_coef
8bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:208
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:141
int first_pic_header_flag
Definition: vc1.h:368
uint16_t * hrd_rate
Definition: vc1.h:326
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1576
void(* sprite_v_double_twoscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset1, const uint8_t *src2a, const uint8_t *src2b, int offset2, int alpha, int width)
Definition: vc1dsp.h:73
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2764
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:201
int second_field
Definition: vc1.h:354
int n_allocated_blks
Definition: vc1.h:385
qpel_mc_func(* qpel_put)[16]
Definition: motion_est.h:91
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:779
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:375
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1647
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:177
int16_t((* luma_mv)[2]
Definition: vc1.h:388
#define FF_API_CAP_VDPAU
Definition: version.h:74
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...
Definition: vc1.h:218
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
MSMPEG4 data tables.
uint8_t * data
Definition: avcodec.h:1467
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:91
#define AV_CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
Definition: avcodec.h:892
#define ff_dlog(a,...)
bitstream reader API header.
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:288
WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstrea...
Definition: pixfmt.h:108
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:312
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:126
ptrdiff_t size
Definition: opengl_enc.c:101
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:419
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:277
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:323
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:762
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
int16_t(* block)[6][64]
Definition: vc1.h:384
static double alpha(void *priv, double x, double y)
Definition: vf_geq.c:99
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1846
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:154
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
ERContext er
Definition: mpegvideo.h:550
int capabilities
Codec capabilities.
Definition: avcodec.h:3411
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define IS_MARKER(state)
Definition: dca_parser.c:45
uint8_t * mv_f_next_base
Definition: vc1.h:351
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1627
simple assert() macros that are a bit more flexible than ISO C assert().
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2929
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
const char * name
Name of the codec implementation.
Definition: avcodec.h:3399
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:404
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:73
GetBitContext gb
Definition: mpegvideo.h:445
GLsizei count
Definition: opengl_enc.c:109
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1116
#define FFMAX(a, b)
Definition: common.h:94
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:349
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2771
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:845
const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]
Definition: vc1data.c:1047
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1825
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3413
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:252
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2811
#define FFMIN(a, b)
Definition: common.h:96
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed b frames
Definition: mpegvideo.h:360
uint8_t * blk_mv_type_base
Definition: vc1.h:349
av_cold void ff_intrax8_common_init(IntraX8Context *w, MpegEncContext *const s)
Initialize IntraX8 frame decoder.
Definition: intrax8.c:692
int field_mode
1 for interlaced field pictures
Definition: vc1.h:352
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:714
int width
picture width / height.
Definition: avcodec.h:1711
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:181
int mb_off
Definition: vc1.h:364
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
int size_in_bits
Definition: get_bits.h:57
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2241
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:628
int level
level
Definition: avcodec.h:3117
MotionEstContext me
Definition: mpegvideo.h:282
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2822
uint32_t * cbp
Definition: vc1.h:386
int left_blk_sh
Definition: vc1.h:240
int16_t(* luma_mv_base)[2]
Definition: vc1.h:388
uint8_t * fieldtx_plane
Definition: vc1.h:346
int * ttblk_base
Definition: vc1.h:259
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:284
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition: vc1.h:377
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: utils.c:1056
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:400
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:183
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:240
Libavcodec external API header.
static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
Definition: vc1_common.h:70
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:131
enum AVCodecID codec_id
Definition: avcodec.h:1549
BlockDSPContext bdsp
Definition: mpegvideo.h:223
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:209
int debug
debug
Definition: avcodec.h:2763
uint32_t * cbp_base
Definition: vc1.h:386
main external API structure.
Definition: avcodec.h:1532
uint8_t * is_intra
Definition: vc1.h:387
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:97
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:894
void * buf
Definition: avisynth_c.h:553
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1961
void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)
Definition: vc1dsp.h:70
int extradata_size
Definition: avcodec.h:1648
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:312
int sprite_width
Definition: vc1.h:376
uint8_t * is_intra_base
Definition: vc1.h:387
int coded_height
Definition: avcodec.h:1726
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:305
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2255
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2248
struct AVFrame * f
Definition: mpegpicture.h:46
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:209
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:418
int context_initialized
Definition: mpegvideo.h:121
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:132
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1190
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:345
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:324
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:287
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:149
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:209
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
AVCodec ff_vc1_decoder
Definition: vc1dec.c:1124
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:286
int blocks_off
Definition: vc1.h:364
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:474
uint8_t tff
Definition: vc1.h:311
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
qpel_mc_func(* qpel_avg)[16]
Definition: motion_est.h:92
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:128
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:442
MpegEncContext s
Definition: vc1.h:174
MpegEncContext.
Definition: mpegvideo.h:78
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:180
struct AVCodecContext * avctx
Definition: mpegvideo.h:95
VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstrea...
Definition: pixfmt.h:109
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:572
#define transpose(x)
const AVProfile ff_vc1_profiles[]
Definition: profiles.c:116
discard all non reference
Definition: avcodec.h:684
static const AVProfile profiles[]
Definition: libfaac.c:216
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
Y , 8bpp.
Definition: pixfmt.h:71
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:127
int output_width
Definition: vc1.h:376
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:308
static double c[64]
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:159
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:179
Bi-dir predicted.
Definition: avutil.h:268
int res_fasttx
reserved, always 1
Definition: vc1.h:187
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:208
int pic_header_flag
Definition: vc1.h:369
int * ttblk
Transform type at the block level.
Definition: vc1.h:259
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:635
void * priv_data
Definition: avcodec.h:1574
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:510
#define PICT_FRAME
Definition: mpegutils.h:39
int picture_structure
Definition: mpegvideo.h:457
#define av_free(p)
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:317
AVFrame * sprite_output_frame
Definition: vc1.h:375
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1422
uint8_t zzi_8x8[64]
Definition: vc1.h:348
void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)
Definition: vc1dsp.h:69
uint8_t rptfrm
Definition: vc1.h:311
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:247
H264ChromaContext h264chroma
Definition: vc1.h:176
int level
Advanced Profile.
Definition: vc1.h:197
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:553
HW decoding through Direct3D11, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer...
Definition: pixfmt.h:243
int new_sprite
Frame decoding info for sprite modes.
Definition: vc1.h:373
uint8_t * mv_f_next[2]
Definition: vc1.h:351
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:783
#define FFSWAP(type, a, b)
Definition: common.h:99
int two_sprites
Definition: vc1.h:374
uint8_t * mb_type[3]
Definition: vc1.h:264
uint16_t * hrd_buffer
Definition: vc1.h:326
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3574
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3585
void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf, int buf_size)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
This structure stores compressed data.
Definition: avcodec.h:1444
static av_always_inline const uint8_t * find_next_marker(const uint8_t *src, const uint8_t *end)
Find VC-1 marker in buffer.
Definition: vc1_common.h:59
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:856
VC1DSPContext vc1dsp
Definition: vc1.h:177
static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:619
int output_height
Definition: vc1.h:376
void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)
Definition: vc1dsp.h:68
static int width