FFmpeg
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 "hwaccel.h"
33 #include "internal.h"
34 #include "mpeg_er.h"
35 #include "mpegvideo.h"
36 #include "msmpeg4.h"
37 #include "msmpeg4data.h"
38 #include "profiles.h"
39 #include "vc1.h"
40 #include "vc1data.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, ret = AVERROR(ENOMEM);
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  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
338  !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
339  goto error;
340 
341  v->n_allocated_blks = s->mb_width + 2;
342  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
343  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
344  if (!v->block || !v->cbp_base)
345  goto error;
346  v->cbp = v->cbp_base + 2 * s->mb_stride;
347  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
348  if (!v->ttblk_base)
349  goto error;
350  v->ttblk = v->ttblk_base + 2 * s->mb_stride;
351  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
352  if (!v->is_intra_base)
353  goto error;
354  v->is_intra = v->is_intra_base + 2 * s->mb_stride;
355  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
356  if (!v->luma_mv_base)
357  goto error;
358  v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
359 
360  /* allocate block type info in that way so it could be used with s->block_index[] */
361  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362  if (!v->mb_type_base)
363  goto error;
364  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
365  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
367 
368  /* allocate memory to store block level MV info */
369  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370  if (!v->blk_mv_type_base)
371  goto error;
372  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
373  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
374  if (!v->mv_f_base)
375  goto error;
376  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
377  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379  if (!v->mv_f_next_base)
380  goto error;
381  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
382  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
383 
385  for (i = 0; i < 4; i++)
386  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
387  return AVERROR(ENOMEM);
388  }
389 
390  ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp,
391  s->block, s->block_last_index,
392  s->mb_width, s->mb_height);
393  if (ret < 0)
394  goto error;
395 
396  return 0;
397 
398 error:
400  return ret;
401 }
402 
404 {
405  int i;
406  for (i = 0; i < 64; i++) {
407 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
408  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
409  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
410  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
411  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
413  }
414  v->left_blk_sh = 0;
415  v->top_blk_sh = 3;
416 }
417 
418 /** Initialize a VC1/WMV3 decoder
419  * @todo TODO: Handle VC-1 IDUs (Transport level?)
420  * @todo TODO: Decipher remaining bits in extra_data
421  */
423 {
424  VC1Context *v = avctx->priv_data;
425  MpegEncContext *s = &v->s;
426  GetBitContext gb;
427  int ret;
428 
429  /* save the container output size for WMImage */
430  v->output_width = avctx->width;
431  v->output_height = avctx->height;
432 
433  if (!avctx->extradata_size || !avctx->extradata)
434  return -1;
435  v->s.avctx = avctx;
436 
437  if ((ret = ff_vc1_init_common(v)) < 0)
438  return ret;
439 
440  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
441  int count = 0;
442 
443  // looks like WMV3 has a sequence header stored in the extradata
444  // advanced sequence header may be before the first frame
445  // the last byte of the extradata is a version number, 1 for the
446  // samples we can decode
447 
448  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
449 
450  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
451  return ret;
452 
453  count = avctx->extradata_size*8 - get_bits_count(&gb);
454  if (count > 0) {
455  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
456  count, get_bits_long(&gb, FFMIN(count, 32)));
457  } else if (count < 0) {
458  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
459  }
460  } else { // VC1/WVC1/WVP2
461  const uint8_t *start = avctx->extradata;
462  uint8_t *end = avctx->extradata + avctx->extradata_size;
463  const uint8_t *next;
464  int size, buf2_size;
465  uint8_t *buf2 = NULL;
466  int seq_initialized = 0, ep_initialized = 0;
467 
468  if (avctx->extradata_size < 16) {
469  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
470  return -1;
471  }
472 
474  if (!buf2)
475  return AVERROR(ENOMEM);
476 
477  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
478  next = start;
479  for (; next < end; start = next) {
480  next = find_next_marker(start + 4, end);
481  size = next - start - 4;
482  if (size <= 0)
483  continue;
484  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
485  init_get_bits(&gb, buf2, buf2_size * 8);
486  switch (AV_RB32(start)) {
487  case VC1_CODE_SEQHDR:
488  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
489  av_free(buf2);
490  return ret;
491  }
492  seq_initialized = 1;
493  break;
494  case VC1_CODE_ENTRYPOINT:
495  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
496  av_free(buf2);
497  return ret;
498  }
499  ep_initialized = 1;
500  break;
501  }
502  }
503  av_free(buf2);
504  if (!seq_initialized || !ep_initialized) {
505  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
506  return -1;
507  }
508  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
509  }
510 
511  avctx->profile = v->profile;
512  if (v->profile == PROFILE_ADVANCED)
513  avctx->level = v->level;
514 
515  if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
516  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
517  else {
518  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
519  if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
520  avctx->color_range = AVCOL_RANGE_MPEG;
521  }
522 
523  // ensure static VLC tables are initialized
524  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
525  return ret;
526  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
527  return ret;
528  // Hack to ensure the above functions will be called
529  // again once we know all necessary settings.
530  // That this is necessary might indicate a bug.
531  ff_vc1_decode_end(avctx);
532 
533  ff_blockdsp_init(&s->bdsp, avctx);
535  ff_qpeldsp_init(&s->qdsp);
536 
537  // Must happen after calling ff_vc1_decode_end
538  // to avoid de-allocating the sprite_output_frame
540  if (!v->sprite_output_frame)
541  return AVERROR(ENOMEM);
542 
543  avctx->has_b_frames = !!avctx->max_b_frames;
544 
545  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
546  avctx->color_primaries = v->color_prim;
547  if (v->transfer_char == 1 || v->transfer_char == 7)
548  avctx->color_trc = v->transfer_char;
549  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
550  avctx->colorspace = v->matrix_coef;
551 
552  s->mb_width = (avctx->coded_width + 15) >> 4;
553  s->mb_height = (avctx->coded_height + 15) >> 4;
554 
555  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
557  } else {
558  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
559  v->left_blk_sh = 3;
560  v->top_blk_sh = 0;
561  }
562 
563  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
564  v->sprite_width = avctx->coded_width;
565  v->sprite_height = avctx->coded_height;
566 
567  avctx->coded_width = avctx->width = v->output_width;
568  avctx->coded_height = avctx->height = v->output_height;
569 
570  // prevent 16.16 overflows
571  if (v->sprite_width > 1 << 14 ||
572  v->sprite_height > 1 << 14 ||
573  v->output_width > 1 << 14 ||
574  v->output_height > 1 << 14) return -1;
575 
576  if ((v->sprite_width&1) || (v->sprite_height&1)) {
577  avpriv_request_sample(avctx, "odd sprites support");
578  return AVERROR_PATCHWELCOME;
579  }
580  }
581  return 0;
582 }
583 
584 /** Close a VC1/WMV3 decoder
585  * @warning Initial try at using MpegEncContext stuff
586  */
588 {
589  VC1Context *v = avctx->priv_data;
590  int i;
591 
593 
594  for (i = 0; i < 4; i++)
595  av_freep(&v->sr_rows[i >> 1][i & 1]);
596  av_freep(&v->hrd_rate);
597  av_freep(&v->hrd_buffer);
598  ff_mpv_common_end(&v->s);
602  av_freep(&v->fieldtx_plane);
603  av_freep(&v->acpred_plane);
605  av_freep(&v->mb_type_base);
607  av_freep(&v->mv_f_base);
609  av_freep(&v->block);
610  av_freep(&v->cbp_base);
611  av_freep(&v->ttblk_base);
612  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
613  av_freep(&v->luma_mv_base);
615  return 0;
616 }
617 
618 
619 /** Decode a VC1/WMV3 frame
620  * @todo TODO: Handle VC-1 IDUs (Transport level?)
621  */
622 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
623  int *got_frame, AVPacket *avpkt)
624 {
625  const uint8_t *buf = avpkt->data;
626  int buf_size = avpkt->size, n_slices = 0, i, ret;
627  VC1Context *v = avctx->priv_data;
628  MpegEncContext *s = &v->s;
629  AVFrame *pict = data;
630  uint8_t *buf2 = NULL;
631  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
632  int mb_height, n_slices1=-1;
633  struct {
634  uint8_t *buf;
635  GetBitContext gb;
636  int mby_start;
637  const uint8_t *rawbuf;
638  int raw_size;
639  } *slices = NULL, *tmp;
640 
641  v->second_field = 0;
642 
644  s->low_delay = 1;
645 
646  /* no supplementary picture */
647  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
648  /* special case for last picture */
649  if (s->low_delay == 0 && s->next_picture_ptr) {
650  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
651  return ret;
652  s->next_picture_ptr = NULL;
653 
654  *got_frame = 1;
655  }
656 
657  return buf_size;
658  }
659 
660  //for advanced profile we may need to parse and unescape data
661  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
662  int buf_size2 = 0;
663  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
664  if (!buf2)
665  return AVERROR(ENOMEM);
666 
667  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
668  const uint8_t *start, *end, *next;
669  int size;
670 
671  next = buf;
672  for (start = buf, end = buf + buf_size; next < end; start = next) {
673  next = find_next_marker(start + 4, end);
674  size = next - start - 4;
675  if (size <= 0) continue;
676  switch (AV_RB32(start)) {
677  case VC1_CODE_FRAME:
678  if (avctx->hwaccel)
679  buf_start = start;
680  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
681  break;
682  case VC1_CODE_FIELD: {
683  int buf_size3;
684  if (avctx->hwaccel)
685  buf_start_second_field = start;
686  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
687  if (!tmp) {
688  ret = AVERROR(ENOMEM);
689  goto err;
690  }
691  slices = tmp;
692  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
693  if (!slices[n_slices].buf) {
694  ret = AVERROR(ENOMEM);
695  goto err;
696  }
697  buf_size3 = vc1_unescape_buffer(start + 4, size,
698  slices[n_slices].buf);
699  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
700  buf_size3 << 3);
701  slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
702  slices[n_slices].rawbuf = start;
703  slices[n_slices].raw_size = size + 4;
704  n_slices1 = n_slices - 1; // index of the last slice of the first field
705  n_slices++;
706  break;
707  }
708  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
709  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
710  init_get_bits(&s->gb, buf2, buf_size2 * 8);
711  ff_vc1_decode_entry_point(avctx, v, &s->gb);
712  break;
713  case VC1_CODE_SLICE: {
714  int buf_size3;
715  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
716  if (!tmp) {
717  ret = AVERROR(ENOMEM);
718  goto err;
719  }
720  slices = tmp;
721  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
722  if (!slices[n_slices].buf) {
723  ret = AVERROR(ENOMEM);
724  goto err;
725  }
726  buf_size3 = vc1_unescape_buffer(start + 4, size,
727  slices[n_slices].buf);
728  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
729  buf_size3 << 3);
730  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
731  slices[n_slices].rawbuf = start;
732  slices[n_slices].raw_size = size + 4;
733  n_slices++;
734  break;
735  }
736  }
737  }
738  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
739  const uint8_t *divider;
740  int buf_size3;
741 
742  divider = find_next_marker(buf, buf + buf_size);
743  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
744  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
745  ret = AVERROR_INVALIDDATA;
746  goto err;
747  } else { // found field marker, unescape second field
748  if (avctx->hwaccel)
749  buf_start_second_field = divider;
750  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
751  if (!tmp) {
752  ret = AVERROR(ENOMEM);
753  goto err;
754  }
755  slices = tmp;
756  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
757  if (!slices[n_slices].buf) {
758  ret = AVERROR(ENOMEM);
759  goto err;
760  }
761  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
762  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
763  buf_size3 << 3);
764  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
765  slices[n_slices].rawbuf = divider;
766  slices[n_slices].raw_size = buf + buf_size - divider;
767  n_slices1 = n_slices - 1;
768  n_slices++;
769  }
770  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
771  } else {
772  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
773  }
774  init_get_bits(&s->gb, buf2, buf_size2*8);
775  } else
776  init_get_bits(&s->gb, buf, buf_size*8);
777 
778  if (v->res_sprite) {
779  v->new_sprite = !get_bits1(&s->gb);
780  v->two_sprites = get_bits1(&s->gb);
781  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
782  we're using the sprite compositor. These are intentionally kept separate
783  so you can get the raw sprites by using the wmv3 decoder for WMVP or
784  the vc1 one for WVP2 */
785  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
786  if (v->new_sprite) {
787  // switch AVCodecContext parameters to those of the sprites
788  avctx->width = avctx->coded_width = v->sprite_width;
789  avctx->height = avctx->coded_height = v->sprite_height;
790  } else {
791  goto image;
792  }
793  }
794  }
795 
796  if (s->context_initialized &&
797  (s->width != avctx->coded_width ||
798  s->height != avctx->coded_height)) {
799  ff_vc1_decode_end(avctx);
800  }
801 
802  if (!s->context_initialized) {
803  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
804  goto err;
805  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
807  goto err;
808  }
809 
810  s->low_delay = !avctx->has_b_frames || v->res_sprite;
811 
812  if (v->profile == PROFILE_ADVANCED) {
813  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
814  ret = AVERROR_INVALIDDATA;
815  goto err;
816  }
817  s->h_edge_pos = avctx->coded_width;
818  s->v_edge_pos = avctx->coded_height;
819  }
820  }
821 
822  // do parse frame header
823  v->pic_header_flag = 0;
824  v->first_pic_header_flag = 1;
825  if (v->profile < PROFILE_ADVANCED) {
826  if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
827  goto err;
828  }
829  } else {
830  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
831  goto err;
832  }
833  }
834  v->first_pic_header_flag = 0;
835 
836  if (avctx->debug & FF_DEBUG_PICT_INFO)
837  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
838 
839  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
840  && s->pict_type != AV_PICTURE_TYPE_I) {
841  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
842  ret = AVERROR_INVALIDDATA;
843  goto err;
844  }
845 
846  if ((s->mb_height >> v->field_mode) == 0) {
847  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
848  ret = AVERROR_INVALIDDATA;
849  goto err;
850  }
851 
852  // for skipping the frame
855 
856  /* skip B-frames if we don't have reference frames */
857  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
858  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
859  goto end;
860  }
861  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
863  avctx->skip_frame >= AVDISCARD_ALL) {
864  goto end;
865  }
866 
867  if (s->next_p_frame_damaged) {
868  if (s->pict_type == AV_PICTURE_TYPE_B)
869  goto end;
870  else
871  s->next_p_frame_damaged = 0;
872  }
873 
874  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
875  goto err;
876  }
877 
881 
882  // process pulldown flags
884  // Pulldown flags are only valid when 'broadcast' has been set.
885  // So ticks_per_frame will be 2
886  if (v->rff) {
887  // repeat field
889  } else if (v->rptfrm) {
890  // repeat frames
891  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
892  }
893 
896 
897  if (avctx->hwaccel) {
898  s->mb_y = 0;
899  if (v->field_mode && buf_start_second_field) {
900  // decode first field
902  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
903  goto err;
904 
905  if (n_slices1 == -1) {
906  // no slices, decode the field as-is
907  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
908  goto err;
909  } else {
910  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
911  goto err;
912 
913  for (i = 0 ; i < n_slices1 + 1; i++) {
914  s->gb = slices[i].gb;
915  s->mb_y = slices[i].mby_start;
916 
917  v->pic_header_flag = get_bits1(&s->gb);
918  if (v->pic_header_flag) {
919  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
920  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
921  ret = AVERROR_INVALIDDATA;
922  if (avctx->err_recognition & AV_EF_EXPLODE)
923  goto err;
924  continue;
925  }
926  }
927 
928  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
929  goto err;
930  }
931  }
932 
933  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
934  goto err;
935 
936  // decode second field
937  s->gb = slices[n_slices1 + 1].gb;
938  s->mb_y = slices[n_slices1 + 1].mby_start;
940  v->second_field = 1;
941  v->pic_header_flag = 0;
942  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
943  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
944  ret = AVERROR_INVALIDDATA;
945  goto err;
946  }
948 
949  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
950  goto err;
951 
952  if (n_slices - n_slices1 == 2) {
953  // no slices, decode the field as-is
954  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
955  goto err;
956  } else {
957  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
958  goto err;
959 
960  for (i = n_slices1 + 2; i < n_slices; i++) {
961  s->gb = slices[i].gb;
962  s->mb_y = slices[i].mby_start;
963 
964  v->pic_header_flag = get_bits1(&s->gb);
965  if (v->pic_header_flag) {
966  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
967  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
968  ret = AVERROR_INVALIDDATA;
969  if (avctx->err_recognition & AV_EF_EXPLODE)
970  goto err;
971  continue;
972  }
973  }
974 
975  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
976  goto err;
977  }
978  }
979 
980  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
981  goto err;
982  } else {
984  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
985  goto err;
986 
987  if (n_slices == 0) {
988  // no slices, decode the frame as-is
989  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
990  goto err;
991  } else {
992  // decode the frame part as the first slice
993  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
994  goto err;
995 
996  // and process the slices as additional slices afterwards
997  for (i = 0 ; i < n_slices; i++) {
998  s->gb = slices[i].gb;
999  s->mb_y = slices[i].mby_start;
1000 
1001  v->pic_header_flag = get_bits1(&s->gb);
1002  if (v->pic_header_flag) {
1003  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1004  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1005  ret = AVERROR_INVALIDDATA;
1006  if (avctx->err_recognition & AV_EF_EXPLODE)
1007  goto err;
1008  continue;
1009  }
1010  }
1011 
1012  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1013  goto err;
1014  }
1015  }
1016  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1017  goto err;
1018  }
1019  } else {
1020  int header_ret = 0;
1021 
1023 
1024  v->bits = buf_size * 8;
1025  v->end_mb_x = s->mb_width;
1026  if (v->field_mode) {
1027  s->current_picture.f->linesize[0] <<= 1;
1028  s->current_picture.f->linesize[1] <<= 1;
1029  s->current_picture.f->linesize[2] <<= 1;
1030  s->linesize <<= 1;
1031  s->uvlinesize <<= 1;
1032  }
1033  mb_height = s->mb_height >> v->field_mode;
1034 
1035  av_assert0 (mb_height > 0);
1036 
1037  for (i = 0; i <= n_slices; i++) {
1038  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1039  if (v->field_mode <= 0) {
1040  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1041  "picture boundary (%d >= %d)\n", i,
1042  slices[i - 1].mby_start, mb_height);
1043  continue;
1044  }
1045  v->second_field = 1;
1046  av_assert0((s->mb_height & 1) == 0);
1047  v->blocks_off = s->b8_stride * (s->mb_height&~1);
1048  v->mb_off = s->mb_stride * s->mb_height >> 1;
1049  } else {
1050  v->second_field = 0;
1051  v->blocks_off = 0;
1052  v->mb_off = 0;
1053  }
1054  if (i) {
1055  v->pic_header_flag = 0;
1056  if (v->field_mode && i == n_slices1 + 2) {
1057  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1058  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1059  ret = AVERROR_INVALIDDATA;
1060  if (avctx->err_recognition & AV_EF_EXPLODE)
1061  goto err;
1062  continue;
1063  }
1064  } else if (get_bits1(&s->gb)) {
1065  v->pic_header_flag = 1;
1066  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1067  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1068  ret = AVERROR_INVALIDDATA;
1069  if (avctx->err_recognition & AV_EF_EXPLODE)
1070  goto err;
1071  continue;
1072  }
1073  }
1074  }
1075  if (header_ret < 0)
1076  continue;
1077  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1078  if (!v->field_mode || v->second_field)
1079  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1080  else {
1081  if (i >= n_slices) {
1082  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1083  continue;
1084  }
1085  s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1086  }
1087  if (s->end_mb_y <= s->start_mb_y) {
1088  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1089  continue;
1090  }
1091  if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1092  (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1093  !v->cbpcy_vlc) {
1094  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1095  continue;
1096  }
1098  if (i != n_slices)
1099  s->gb = slices[i].gb;
1100  }
1101  if (v->field_mode) {
1102  v->second_field = 0;
1103  s->current_picture.f->linesize[0] >>= 1;
1104  s->current_picture.f->linesize[1] >>= 1;
1105  s->current_picture.f->linesize[2] >>= 1;
1106  s->linesize >>= 1;
1107  s->uvlinesize >>= 1;
1109  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1110  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1111  }
1112  }
1113  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1114  get_bits_count(&s->gb), s->gb.size_in_bits);
1115 // if (get_bits_count(&s->gb) > buf_size * 8)
1116 // return -1;
1117  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1118  ret = AVERROR_INVALIDDATA;
1119  goto err;
1120  }
1121  if (!v->field_mode)
1122  ff_er_frame_end(&s->er);
1123  }
1124 
1125  ff_mpv_frame_end(s);
1126 
1127  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1128 image:
1129  avctx->width = avctx->coded_width = v->output_width;
1130  avctx->height = avctx->coded_height = v->output_height;
1131  if (avctx->skip_frame >= AVDISCARD_NONREF)
1132  goto end;
1133 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1134  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1135  goto err;
1136 #endif
1137  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1138  goto err;
1139  *got_frame = 1;
1140  } else {
1141  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1142  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1143  goto err;
1145  *got_frame = 1;
1146  } else if (s->last_picture_ptr) {
1147  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1148  goto err;
1150  *got_frame = 1;
1151  }
1152  }
1153 
1154 end:
1155  av_free(buf2);
1156  for (i = 0; i < n_slices; i++)
1157  av_free(slices[i].buf);
1158  av_free(slices);
1159  return buf_size;
1160 
1161 err:
1162  av_free(buf2);
1163  for (i = 0; i < n_slices; i++)
1164  av_free(slices[i].buf);
1165  av_free(slices);
1166  return ret;
1167 }
1168 
1169 
1171 #if CONFIG_VC1_DXVA2_HWACCEL
1173 #endif
1174 #if CONFIG_VC1_D3D11VA_HWACCEL
1177 #endif
1178 #if CONFIG_VC1_NVDEC_HWACCEL
1180 #endif
1181 #if CONFIG_VC1_VAAPI_HWACCEL
1183 #endif
1184 #if CONFIG_VC1_VDPAU_HWACCEL
1186 #endif
1189 };
1190 
1192  .name = "vc1",
1193  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1194  .type = AVMEDIA_TYPE_VIDEO,
1195  .id = AV_CODEC_ID_VC1,
1196  .priv_data_size = sizeof(VC1Context),
1197  .init = vc1_decode_init,
1198  .close = ff_vc1_decode_end,
1200  .flush = ff_mpeg_flush,
1201  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1202  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1203  .hw_configs = (const AVCodecHWConfigInternal*[]) {
1204 #if CONFIG_VC1_DXVA2_HWACCEL
1205  HWACCEL_DXVA2(vc1),
1206 #endif
1207 #if CONFIG_VC1_D3D11VA_HWACCEL
1208  HWACCEL_D3D11VA(vc1),
1209 #endif
1210 #if CONFIG_VC1_D3D11VA2_HWACCEL
1211  HWACCEL_D3D11VA2(vc1),
1212 #endif
1213 #if CONFIG_VC1_NVDEC_HWACCEL
1214  HWACCEL_NVDEC(vc1),
1215 #endif
1216 #if CONFIG_VC1_VAAPI_HWACCEL
1217  HWACCEL_VAAPI(vc1),
1218 #endif
1219 #if CONFIG_VC1_VDPAU_HWACCEL
1220  HWACCEL_VDPAU(vc1),
1221 #endif
1222  NULL
1223  },
1225 };
1226 
1227 #if CONFIG_WMV3_DECODER
1229  .name = "wmv3",
1230  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1231  .type = AVMEDIA_TYPE_VIDEO,
1232  .id = AV_CODEC_ID_WMV3,
1233  .priv_data_size = sizeof(VC1Context),
1234  .init = vc1_decode_init,
1235  .close = ff_vc1_decode_end,
1237  .flush = ff_mpeg_flush,
1238  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1239  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1240  .hw_configs = (const AVCodecHWConfigInternal*[]) {
1241 #if CONFIG_WMV3_DXVA2_HWACCEL
1242  HWACCEL_DXVA2(wmv3),
1243 #endif
1244 #if CONFIG_WMV3_D3D11VA_HWACCEL
1245  HWACCEL_D3D11VA(wmv3),
1246 #endif
1247 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1248  HWACCEL_D3D11VA2(wmv3),
1249 #endif
1250 #if CONFIG_WMV3_NVDEC_HWACCEL
1251  HWACCEL_NVDEC(wmv3),
1252 #endif
1253 #if CONFIG_WMV3_VAAPI_HWACCEL
1254  HWACCEL_VAAPI(wmv3),
1255 #endif
1256 #if CONFIG_WMV3_VDPAU_HWACCEL
1257  HWACCEL_VDPAU(wmv3),
1258 #endif
1259  NULL
1260  },
1262 };
1263 #endif
1264 
1265 #if CONFIG_WMV3IMAGE_DECODER
1267  .name = "wmv3image",
1268  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1269  .type = AVMEDIA_TYPE_VIDEO,
1270  .id = AV_CODEC_ID_WMV3IMAGE,
1271  .priv_data_size = sizeof(VC1Context),
1272  .init = vc1_decode_init,
1273  .close = ff_vc1_decode_end,
1275  .capabilities = AV_CODEC_CAP_DR1,
1276  .flush = vc1_sprite_flush,
1277  .pix_fmts = (const enum AVPixelFormat[]) {
1279  AV_PIX_FMT_NONE
1280  },
1281 };
1282 #endif
1283 
1284 #if CONFIG_VC1IMAGE_DECODER
1286  .name = "vc1image",
1287  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1288  .type = AVMEDIA_TYPE_VIDEO,
1289  .id = AV_CODEC_ID_VC1IMAGE,
1290  .priv_data_size = sizeof(VC1Context),
1291  .init = vc1_decode_init,
1292  .close = ff_vc1_decode_end,
1294  .capabilities = AV_CODEC_CAP_DR1,
1295  .flush = vc1_sprite_flush,
1296  .pix_fmts = (const enum AVPixelFormat[]) {
1298  AV_PIX_FMT_NONE
1299  },
1300 };
1301 #endif
int color_prim
8 bits, 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:384
AVCodec ff_wmv3image_decoder
IDCTDSPContext idsp
Definition: mpegvideo.h:230
#define NULL
Definition: coverity.c:32
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1371
const struct AVCodec * codec
Definition: avcodec.h:1574
discard all frames except keyframes
Definition: avcodec.h:810
BI type.
Definition: avutil.h:280
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:74
int p_frame_skipped
Definition: vc1.h:386
#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:295
#define HWACCEL_D3D11VA2(codec)
Definition: hwaccel.h:69
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:153
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:70
static void flush(AVCodecContext *avctx)
uint8_t * mv_f_base
Definition: vc1.h:351
#define HWACCEL_NVDEC(codec)
Definition: hwaccel.h:71
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1753
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:301
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:154
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:1825
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:587
#define avpriv_request_sample(...)
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:132
void ff_er_frame_end(ERContext *s)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2200
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:437
int size
Definition: avcodec.h:1478
int transfer_char
8 bits, Opto-electronic transfer characteristics
Definition: vc1.h:207
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)
Definition: vc1dsp.h:68
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:1775
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1170
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
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
discard all
Definition: avcodec.h:811
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:351
int sprite_height
Definition: vc1.h:382
#define HWACCEL_D3D11VA(codec)
Definition: hwaccel.h:79
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:399
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2729
int profile
profile
Definition: avcodec.h:2898
QpelDSPContext qdsp
Definition: mpegvideo.h:235
AVCodec.
Definition: avcodec.h:3481
av_cold int ff_intrax8_common_init(AVCodecContext *avctx, IntraX8Context *w, IDCTDSPContext *idsp, int16_t(*block)[64], int block_last_index[12], int mb_width, int mb_height)
Initialize IntraX8 frame decoder.
Definition: intrax8.c:728
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
uint8_t rff
Definition: vc1.h:312
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3040
int bits
Definition: vc1.h:179
#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:1006
#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:322
VC-1 tables.
int bi_type
Definition: vc1.h:387
int matrix_coef
8 bits, 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:189
int first_pic_header_flag
Definition: vc1.h:369
uint16_t * hrd_rate
Definition: vc1.h:327
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1577
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2651
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:201
int second_field
Definition: vc1.h:355
int n_allocated_blks
Definition: vc1.h:391
qpel_mc_func(* qpel_put)[16]
Definition: motion_est.h:91
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:900
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:443
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
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:180
int16_t((* luma_mv)[2]
Definition: vc1.h:394
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:1477
#define HWACCEL_DXVA2(codec)
Definition: hwaccel.h:67
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
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:88
#define ff_dlog(a,...)
bitstream reader API header.
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:288
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
ptrdiff_t size
Definition: opengl_enc.c:100
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:422
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:276
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:324
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define FFALIGN(x, a)
Definition: macros.h:48
AVCodec ff_wmv3_decoder
#define av_log(a,...)
int16_t(* block)[6][64]
Definition: vc1.h:390
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#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:1855
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
ERContext er
Definition: mpegvideo.h:566
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define IS_MARKER(state)
Definition: dca_parser.c:51
uint8_t * mv_f_next_base
Definition: vc1.h:352
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
simple assert() macros that are a bit more flexible than ISO C assert().
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2967
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:73
GetBitContext gb
Definition: mpegvideo.h:448
GLsizei count
Definition: opengl_enc.c:108
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1133
#define FFMAX(a, b)
Definition: common.h:94
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:350
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2307
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:841
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:1809
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3502
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2694
#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:350
#define width
int field_mode
1 for interlaced field pictures
Definition: vc1.h:353
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:768
int width
picture width / height.
Definition: avcodec.h:1738
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
int mb_off
Definition: vc1.h:365
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
int size_in_bits
Definition: get_bits.h:68
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2179
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:622
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:3018
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
MotionEstContext me
Definition: mpegvideo.h:282
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
HW acceleration through CUDA.
Definition: pixfmt.h:235
uint32_t * cbp
Definition: vc1.h:392
static void error(const char *err)
int left_blk_sh
Definition: vc1.h:240
int16_t(* luma_mv_base)[2]
Definition: vc1.h:394
uint8_t * fieldtx_plane
Definition: vc1.h:347
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:383
#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:403
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.
void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)
Definition: vc1dsp.h:69
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:134
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3750
enum AVCodecID codec_id
Definition: avcodec.h:1575
BlockDSPContext bdsp
Definition: mpegvideo.h:226
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
#define abs(x)
Definition: cuda_runtime.h:35
int debug
debug
Definition: avcodec.h:2650
uint32_t * cbp_base
Definition: vc1.h:392
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1565
uint8_t * is_intra
Definition: vc1.h:393
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
void * buf
Definition: avisynth_c.h:766
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1439
int extradata_size
Definition: avcodec.h:1667
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int sprite_width
Definition: vc1.h:382
uint8_t * is_intra_base
Definition: vc1.h:393
int coded_height
Definition: avcodec.h:1753
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2193
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2186
struct AVFrame * f
Definition: mpegpicture.h:46
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:72
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:197
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
int context_initialized
Definition: mpegvideo.h:124
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:135
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:1207
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
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:137
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
AVCodec ff_vc1_decoder
Definition: vc1dec.c:1191
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:286
#define HWACCEL_VAAPI(codec)
Definition: hwaccel.h:73
int blocks_off
Definition: vc1.h:365
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3739
uint8_t tff
Definition: vc1.h:312
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
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:131
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:313
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
MpegEncContext s
Definition: vc1.h:174
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:3711
MpegEncContext.
Definition: mpegvideo.h:81
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:183
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
#define transpose(x)
const AVProfile ff_vc1_profiles[]
Definition: profiles.c:126
discard all non reference
Definition: avcodec.h:807
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
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:130
int output_width
Definition: vc1.h:382
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:309
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:162
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:182
Bi-dir predicted.
Definition: avutil.h:276
int res_fasttx
reserved, always 1
Definition: vc1.h:187
int pic_header_flag
Definition: vc1.h:370
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:790
void * priv_data
Definition: avcodec.h:1592
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:504
#define PICT_FRAME
Definition: mpegutils.h:39
int picture_structure
Definition: mpegvideo.h:461
#define av_free(p)
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
AVFrame * sprite_output_frame
Definition: vc1.h:381
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1431
uint8_t zzi_8x8[64]
Definition: vc1.h:349
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:508
AVCodec ff_vc1image_decoder
uint8_t rptfrm
Definition: vc1.h:312
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
H264ChromaContext h264chroma
Definition: vc1.h:176
int level
Advanced Profile.
Definition: vc1.h:197
#define av_freep(p)
#define HWACCEL_VDPAU(codec)
Definition: hwaccel.h:75
void INT64 start
Definition: avisynth_c.h:766
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:229
int new_sprite
Frame decoding info for sprite modes.
Definition: vc1.h:379
uint8_t * mv_f_next[2]
Definition: vc1.h:352
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:380
uint8_t * mb_type[3]
Definition: vc1.h:264
void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)
Definition: vc1dsp.h:67
uint16_t * hrd_buffer
Definition: vc1.h:327
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
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
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
VC1DSPContext vc1dsp
Definition: vc1.h:177
Predicted.
Definition: avutil.h:275
static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:622
int output_height
Definition: vc1.h:382
static uint8_t tmp[11]
Definition: aes_ctr.c:26