FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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 "vc1.h"
38 #include "vc1data.h"
39 #include "vdpau_compat.h"
40 #include "libavutil/avassert.h"
41 
42 
43 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
44 
45 typedef struct SpriteData {
46  /**
47  * Transform coefficients for both sprites in 16.16 fixed point format,
48  * in the order they appear in the bitstream:
49  * x scale
50  * rotation 1 (unused)
51  * x offset
52  * rotation 2 (unused)
53  * y scale
54  * y offset
55  * alpha
56  */
57  int coefs[2][7];
58 
59  int effect_type, effect_flag;
60  int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
61  int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
62 } SpriteData;
63 
64 static inline int get_fp_val(GetBitContext* gb)
65 {
66  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
67 }
68 
69 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
70 {
71  c[1] = c[3] = 0;
72 
73  switch (get_bits(gb, 2)) {
74  case 0:
75  c[0] = 1 << 16;
76  c[2] = get_fp_val(gb);
77  c[4] = 1 << 16;
78  break;
79  case 1:
80  c[0] = c[4] = get_fp_val(gb);
81  c[2] = get_fp_val(gb);
82  break;
83  case 2:
84  c[0] = get_fp_val(gb);
85  c[2] = get_fp_val(gb);
86  c[4] = get_fp_val(gb);
87  break;
88  case 3:
89  c[0] = get_fp_val(gb);
90  c[1] = get_fp_val(gb);
91  c[2] = get_fp_val(gb);
92  c[3] = get_fp_val(gb);
93  c[4] = get_fp_val(gb);
94  break;
95  }
96  c[5] = get_fp_val(gb);
97  if (get_bits1(gb))
98  c[6] = get_fp_val(gb);
99  else
100  c[6] = 1 << 16;
101 }
102 
103 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
104 {
105  AVCodecContext *avctx = v->s.avctx;
106  int sprite, i;
107 
108  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
109  vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
110  if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
111  avpriv_request_sample(avctx, "Non-zero rotation coefficients");
112  av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
113  for (i = 0; i < 7; i++)
114  av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
115  sd->coefs[sprite][i] / (1<<16),
116  (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
117  av_log(avctx, AV_LOG_DEBUG, "\n");
118  }
119 
120  skip_bits(gb, 2);
121  if (sd->effect_type = get_bits_long(gb, 30)) {
122  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
123  case 7:
124  vc1_sprite_parse_transform(gb, sd->effect_params1);
125  break;
126  case 14:
127  vc1_sprite_parse_transform(gb, sd->effect_params1);
128  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
129  break;
130  default:
131  for (i = 0; i < sd->effect_pcount1; i++)
132  sd->effect_params1[i] = get_fp_val(gb);
133  }
134  if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
135  // effect 13 is simple alpha blending and matches the opacity above
136  av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
137  for (i = 0; i < sd->effect_pcount1; i++)
138  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
139  sd->effect_params1[i] / (1 << 16),
140  (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
141  av_log(avctx, AV_LOG_DEBUG, "\n");
142  }
143 
144  sd->effect_pcount2 = get_bits(gb, 16);
145  if (sd->effect_pcount2 > 10) {
146  av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
147  return AVERROR_INVALIDDATA;
148  } else if (sd->effect_pcount2) {
149  i = -1;
150  av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
151  while (++i < sd->effect_pcount2) {
152  sd->effect_params2[i] = get_fp_val(gb);
153  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
154  sd->effect_params2[i] / (1 << 16),
155  (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
156  }
157  av_log(avctx, AV_LOG_DEBUG, "\n");
158  }
159  }
160  if (sd->effect_flag = get_bits1(gb))
161  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
162 
163  if (get_bits_count(gb) >= gb->size_in_bits +
164  (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
165  av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
166  return AVERROR_INVALIDDATA;
167  }
168  if (get_bits_count(gb) < gb->size_in_bits - 8)
169  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
170 
171  return 0;
172 }
173 
174 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
175 {
176  int i, plane, row, sprite;
177  int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
178  uint8_t* src_h[2][2];
179  int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
180  int ysub[2];
181  MpegEncContext *s = &v->s;
182 
183  for (i = 0; i <= v->two_sprites; i++) {
184  xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
185  xadv[i] = sd->coefs[i][0];
186  if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
187  xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
188 
189  yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
190  yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
191  }
192  alpha = av_clip_uint16(sd->coefs[1][6]);
193 
194  for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
195  int width = v->output_width>>!!plane;
196 
197  for (row = 0; row < v->output_height>>!!plane; row++) {
198  uint8_t *dst = v->sprite_output_frame->data[plane] +
200 
201  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
202  uint8_t *iplane = s->current_picture.f->data[plane];
203  int iline = s->current_picture.f->linesize[plane];
204  int ycoord = yoff[sprite] + yadv[sprite] * row;
205  int yline = ycoord >> 16;
206  int next_line;
207  ysub[sprite] = ycoord & 0xFFFF;
208  if (sprite) {
209  iplane = s->last_picture.f->data[plane];
210  iline = s->last_picture.f->linesize[plane];
211  }
212  next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
213  if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
214  src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
215  if (ysub[sprite])
216  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
217  } else {
218  if (sr_cache[sprite][0] != yline) {
219  if (sr_cache[sprite][1] == yline) {
220  FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
221  FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
222  } else {
223  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
224  sr_cache[sprite][0] = yline;
225  }
226  }
227  if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
228  v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
229  iplane + next_line, xoff[sprite],
230  xadv[sprite], width);
231  sr_cache[sprite][1] = yline + 1;
232  }
233  src_h[sprite][0] = v->sr_rows[sprite][0];
234  src_h[sprite][1] = v->sr_rows[sprite][1];
235  }
236  }
237 
238  if (!v->two_sprites) {
239  if (ysub[0]) {
240  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
241  } else {
242  memcpy(dst, src_h[0][0], width);
243  }
244  } else {
245  if (ysub[0] && ysub[1]) {
246  v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
247  src_h[1][0], src_h[1][1], ysub[1], alpha, width);
248  } else if (ysub[0]) {
249  v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
250  src_h[1][0], alpha, width);
251  } else if (ysub[1]) {
252  v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
253  src_h[0][0], (1<<16)-1-alpha, width);
254  } else {
255  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
256  }
257  }
258  }
259 
260  if (!plane) {
261  for (i = 0; i <= v->two_sprites; i++) {
262  xoff[i] >>= 1;
263  yoff[i] >>= 1;
264  }
265  }
266 
267  }
268 }
269 
270 
271 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
272 {
273  int ret;
274  MpegEncContext *s = &v->s;
275  AVCodecContext *avctx = s->avctx;
276  SpriteData sd;
277 
278  memset(&sd, 0, sizeof(sd));
279 
280  ret = vc1_parse_sprites(v, gb, &sd);
281  if (ret < 0)
282  return ret;
283 
284  if (!s->current_picture.f || !s->current_picture.f->data[0]) {
285  av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
286  return AVERROR_UNKNOWN;
287  }
288 
289  if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
290  av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
291  v->two_sprites = 0;
292  }
293 
295  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
296  return ret;
297 
298  vc1_draw_sprites(v, &sd);
299 
300  return 0;
301 }
302 
303 static void vc1_sprite_flush(AVCodecContext *avctx)
304 {
305  VC1Context *v = avctx->priv_data;
306  MpegEncContext *s = &v->s;
307  AVFrame *f = s->current_picture.f;
308  int plane, i;
309 
310  /* Windows Media Image codecs have a convergence interval of two keyframes.
311  Since we can't enforce it, clear to black the missing sprite. This is
312  wrong but it looks better than doing nothing. */
313 
314  if (f && f->data[0])
315  for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
316  for (i = 0; i < v->sprite_height>>!!plane; i++)
317  memset(f->data[plane] + i * f->linesize[plane],
318  plane ? 128 : 0, f->linesize[plane]);
319 }
320 
321 #endif
322 
324 {
325  MpegEncContext *s = &v->s;
326  int i;
327  int mb_height = FFALIGN(s->mb_height, 2);
328 
329  /* Allocate mb bitplanes */
330  v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
331  v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
332  v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
333  v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
334  v->acpred_plane = av_malloc (s->mb_stride * mb_height);
335  v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
336 
337  v->n_allocated_blks = s->mb_width + 2;
338  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
339  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
340  v->cbp = v->cbp_base + s->mb_stride;
341  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
342  v->ttblk = v->ttblk_base + s->mb_stride;
343  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
344  v->is_intra = v->is_intra_base + s->mb_stride;
345  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
346  v->luma_mv = v->luma_mv_base + s->mb_stride;
347 
348  /* allocate block type info in that way so it could be used with s->block_index[] */
349  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
350  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
351  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
352  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
353 
354  /* allocate memory to store block level MV info */
355  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
356  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
357  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
358  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
359  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
360  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
361  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
362  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
363 
364  /* Init coded blocks info */
365  if (v->profile == PROFILE_ADVANCED) {
366 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
367 // return -1;
368 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
369 // return -1;
370  }
371 
372  ff_intrax8_common_init(&v->x8,s);
373 
375  for (i = 0; i < 4; i++)
376  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
377  return AVERROR(ENOMEM);
378  }
379 
380  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
381  !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
382  !v->mb_type_base) {
385  av_freep(&v->acpred_plane);
387  av_freep(&v->block);
388  av_freep(&v->cbp_base);
389  av_freep(&v->ttblk_base);
390  av_freep(&v->is_intra_base);
391  av_freep(&v->luma_mv_base);
392  av_freep(&v->mb_type_base);
393  return AVERROR(ENOMEM);
394  }
395 
396  return 0;
397 }
398 
400 {
401  int i;
402  for (i = 0; i < 64; i++) {
403 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
404  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
405  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
406  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
407  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
409  }
410  v->left_blk_sh = 0;
411  v->top_blk_sh = 3;
412 }
413 
414 /** Initialize a VC1/WMV3 decoder
415  * @todo TODO: Handle VC-1 IDUs (Transport level?)
416  * @todo TODO: Decypher remaining bits in extra_data
417  */
419 {
420  VC1Context *v = avctx->priv_data;
421  MpegEncContext *s = &v->s;
422  GetBitContext gb;
423  int ret;
424 
425  /* save the container output size for WMImage */
426  v->output_width = avctx->width;
427  v->output_height = avctx->height;
428 
429  if (!avctx->extradata_size || !avctx->extradata)
430  return AVERROR_INVALIDDATA;
431  v->s.avctx = avctx;
432 
433  if ((ret = ff_vc1_init_common(v)) < 0)
434  return ret;
435 
436  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
437  int count = 0;
438 
439  // looks like WMV3 has a sequence header stored in the extradata
440  // advanced sequence header may be before the first frame
441  // the last byte of the extradata is a version number, 1 for the
442  // samples we can decode
443 
444  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
445 
446  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
447  return ret;
448 
449  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
450  avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
451  return AVERROR_PATCHWELCOME;
452  }
453 
454  count = avctx->extradata_size*8 - get_bits_count(&gb);
455  if (count > 0) {
456  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
457  count, get_bits_long(&gb, FFMIN(count, 32)));
458  } else if (count < 0) {
459  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
460  }
461  } else { // VC1/WVC1/WVP2
462  const uint8_t *start = avctx->extradata;
463  uint8_t *end = avctx->extradata + avctx->extradata_size;
464  const uint8_t *next;
465  int size, buf2_size;
466  uint8_t *buf2 = NULL;
467  int seq_initialized = 0, ep_initialized = 0;
468 
469  if (avctx->extradata_size < 16) {
470  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
471  return AVERROR_INVALIDDATA;
472  }
473 
475  if (!buf2)
476  return AVERROR(ENOMEM);
477 
478  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
479  next = start;
480  for (; next < end; start = next) {
481  next = find_next_marker(start + 4, end);
482  size = next - start - 4;
483  if (size <= 0)
484  continue;
485  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
486  init_get_bits(&gb, buf2, buf2_size * 8);
487  switch (AV_RB32(start)) {
488  case VC1_CODE_SEQHDR:
489  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
490  av_free(buf2);
491  return ret;
492  }
493  seq_initialized = 1;
494  break;
495  case VC1_CODE_ENTRYPOINT:
496  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
497  av_free(buf2);
498  return ret;
499  }
500  ep_initialized = 1;
501  break;
502  }
503  }
504  av_free(buf2);
505  if (!seq_initialized || !ep_initialized) {
506  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
507  return AVERROR_INVALIDDATA;
508  }
509  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
510  }
511 
512  avctx->profile = v->profile;
513  if (v->profile == PROFILE_ADVANCED)
514  avctx->level = v->level;
515 
516  if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
517  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
518  else {
519  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
520  if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
521  avctx->color_range = AVCOL_RANGE_MPEG;
522  }
523 
524  // ensure static VLC tables are initialized
525  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
526  return ret;
527  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
528  return ret;
529  // Hack to ensure the above functions will be called
530  // again once we know all necessary settings.
531  // That this is necessary might indicate a bug.
532  ff_vc1_decode_end(avctx);
533 
534  ff_blockdsp_init(&s->bdsp, avctx);
536  ff_qpeldsp_init(&s->qdsp);
537 
538  // Must happen after calling ff_vc1_decode_end
539  // to avoid de-allocating the sprite_output_frame
541  if (!v->sprite_output_frame)
542  return AVERROR(ENOMEM);
543 
544  avctx->has_b_frames = !!avctx->max_b_frames;
545 
546  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
547  avctx->color_primaries = v->color_prim;
548  if (v->transfer_char == 1 || v->transfer_char == 7)
549  avctx->color_trc = v->transfer_char;
550  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
551  avctx->colorspace = v->matrix_coef;
552 
553  s->mb_width = (avctx->coded_width + 15) >> 4;
554  s->mb_height = (avctx->coded_height + 15) >> 4;
555 
556  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
558  } else {
559  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
560  v->left_blk_sh = 3;
561  v->top_blk_sh = 0;
562  }
563 
564  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
565  v->sprite_width = avctx->coded_width;
566  v->sprite_height = avctx->coded_height;
567 
568  avctx->coded_width = avctx->width = v->output_width;
569  avctx->coded_height = avctx->height = v->output_height;
570 
571  // prevent 16.16 overflows
572  if (v->sprite_width > 1 << 14 ||
573  v->sprite_height > 1 << 14 ||
574  v->output_width > 1 << 14 ||
575  v->output_height > 1 << 14) {
576  ret = AVERROR_INVALIDDATA;
577  goto error;
578  }
579 
580  if ((v->sprite_width&1) || (v->sprite_height&1)) {
581  avpriv_request_sample(avctx, "odd sprites support");
582  ret = AVERROR_PATCHWELCOME;
583  goto error;
584  }
585  }
586  return 0;
587 error:
589  return ret;
590 }
591 
592 /** Close a VC1/WMV3 decoder
593  * @warning Initial try at using MpegEncContext stuff
594  */
596 {
597  VC1Context *v = avctx->priv_data;
598  int i;
599 
601 
602  for (i = 0; i < 4; i++)
603  av_freep(&v->sr_rows[i >> 1][i & 1]);
604  av_freep(&v->hrd_rate);
605  av_freep(&v->hrd_buffer);
606  ff_mpv_common_end(&v->s);
610  av_freep(&v->fieldtx_plane);
611  av_freep(&v->acpred_plane);
613  av_freep(&v->mb_type_base);
615  av_freep(&v->mv_f_base);
617  av_freep(&v->block);
618  av_freep(&v->cbp_base);
619  av_freep(&v->ttblk_base);
620  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
621  av_freep(&v->luma_mv_base);
623  return 0;
624 }
625 
626 
627 /** Decode a VC1/WMV3 frame
628  * @todo TODO: Handle VC-1 IDUs (Transport level?)
629  */
630 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
631  int *got_frame, AVPacket *avpkt)
632 {
633  const uint8_t *buf = avpkt->data;
634  int buf_size = avpkt->size, n_slices = 0, i, ret;
635  VC1Context *v = avctx->priv_data;
636  MpegEncContext *s = &v->s;
637  AVFrame *pict = data;
638  uint8_t *buf2 = NULL;
639  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
640  int mb_height, n_slices1=-1;
641  struct {
642  uint8_t *buf;
643  GetBitContext gb;
644  int mby_start;
645  } *slices = NULL, *tmp;
646 
647  v->second_field = 0;
648 
650  s->low_delay = 1;
651 
652  /* no supplementary picture */
653  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
654  /* special case for last picture */
655  if (s->low_delay == 0 && s->next_picture_ptr) {
656  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
657  return ret;
658  s->next_picture_ptr = NULL;
659 
660  *got_frame = 1;
661  }
662 
663  return buf_size;
664  }
665 
666 #if FF_API_CAP_VDPAU
668  if (v->profile < PROFILE_ADVANCED)
670  else
671  avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
672  }
673 #endif
674 
675  //for advanced profile we may need to parse and unescape data
676  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
677  int buf_size2 = 0;
678  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
679  if (!buf2)
680  return AVERROR(ENOMEM);
681 
682  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
683  const uint8_t *start, *end, *next;
684  int size;
685 
686  next = buf;
687  for (start = buf, end = buf + buf_size; next < end; start = next) {
688  next = find_next_marker(start + 4, end);
689  size = next - start - 4;
690  if (size <= 0) continue;
691  switch (AV_RB32(start)) {
692  case VC1_CODE_FRAME:
693  if (avctx->hwaccel
696 #endif
697  )
698  buf_start = start;
699  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
700  break;
701  case VC1_CODE_FIELD: {
702  int buf_size3;
703  if (avctx->hwaccel
706 #endif
707  )
708  buf_start_second_field = start;
709  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
710  if (!tmp) {
711  ret = AVERROR(ENOMEM);
712  goto err;
713  }
714  slices = tmp;
715  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
716  if (!slices[n_slices].buf) {
717  ret = AVERROR(ENOMEM);
718  goto err;
719  }
720  buf_size3 = vc1_unescape_buffer(start + 4, size,
721  slices[n_slices].buf);
722  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
723  buf_size3 << 3);
724  /* assuming that the field marker is at the exact middle,
725  hope it's correct */
726  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
727  n_slices1 = n_slices - 1; // index of the last slice of the first field
728  n_slices++;
729  break;
730  }
731  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
732  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
733  init_get_bits(&s->gb, buf2, buf_size2 * 8);
734  ff_vc1_decode_entry_point(avctx, v, &s->gb);
735  break;
736  case VC1_CODE_SLICE: {
737  int buf_size3;
738  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
739  if (!tmp) {
740  ret = AVERROR(ENOMEM);
741  goto err;
742  }
743  slices = tmp;
744  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
745  if (!slices[n_slices].buf) {
746  ret = AVERROR(ENOMEM);
747  goto err;
748  }
749  buf_size3 = vc1_unescape_buffer(start + 4, size,
750  slices[n_slices].buf);
751  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
752  buf_size3 << 3);
753  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
754  n_slices++;
755  break;
756  }
757  }
758  }
759  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
760  const uint8_t *divider;
761  int buf_size3;
762 
763  divider = find_next_marker(buf, buf + buf_size);
764  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
765  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
766  ret = AVERROR_INVALIDDATA;
767  goto err;
768  } else { // found field marker, unescape second field
769  if (avctx->hwaccel
772 #endif
773  )
774  buf_start_second_field = divider;
775  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
776  if (!tmp) {
777  ret = AVERROR(ENOMEM);
778  goto err;
779  }
780  slices = tmp;
781  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
782  if (!slices[n_slices].buf) {
783  ret = AVERROR(ENOMEM);
784  goto err;
785  }
786  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
787  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
788  buf_size3 << 3);
789  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
790  n_slices1 = n_slices - 1;
791  n_slices++;
792  }
793  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
794  } else {
795  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
796  }
797  init_get_bits(&s->gb, buf2, buf_size2*8);
798  } else
799  init_get_bits(&s->gb, buf, buf_size*8);
800 
801  if (v->res_sprite) {
802  v->new_sprite = !get_bits1(&s->gb);
803  v->two_sprites = get_bits1(&s->gb);
804  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
805  we're using the sprite compositor. These are intentionally kept separate
806  so you can get the raw sprites by using the wmv3 decoder for WMVP or
807  the vc1 one for WVP2 */
808  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
809  if (v->new_sprite) {
810  // switch AVCodecContext parameters to those of the sprites
811  avctx->width = avctx->coded_width = v->sprite_width;
812  avctx->height = avctx->coded_height = v->sprite_height;
813  } else {
814  goto image;
815  }
816  }
817  }
818 
819  if (s->context_initialized &&
820  (s->width != avctx->coded_width ||
821  s->height != avctx->coded_height)) {
822  ff_vc1_decode_end(avctx);
823  }
824 
825  if (!s->context_initialized) {
826  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
827  goto err;
828  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
830  goto err;
831  }
832 
833  s->low_delay = !avctx->has_b_frames || v->res_sprite;
834 
835  if (v->profile == PROFILE_ADVANCED) {
836  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
837  ret = AVERROR_INVALIDDATA;
838  goto err;
839  }
840  s->h_edge_pos = avctx->coded_width;
841  s->v_edge_pos = avctx->coded_height;
842  }
843  }
844 
845  // do parse frame header
846  v->pic_header_flag = 0;
847  v->first_pic_header_flag = 1;
848  if (v->profile < PROFILE_ADVANCED) {
849  if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
850  goto err;
851  }
852  } else {
853  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
854  goto err;
855  }
856  }
857  v->first_pic_header_flag = 0;
858 
859  if (avctx->debug & FF_DEBUG_PICT_INFO)
860  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
861 
862  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
863  && s->pict_type != AV_PICTURE_TYPE_I) {
864  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
865  ret = AVERROR_INVALIDDATA;
866  goto err;
867  }
868  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
869  && v->field_mode) {
870  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
871  ret = AVERROR_INVALIDDATA;
872  goto err;
873  }
874  if ((s->mb_height >> v->field_mode) == 0) {
875  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
876  ret = AVERROR_INVALIDDATA;
877  goto err;
878  }
879 
880  // for skipping the frame
883 
884  /* skip B-frames if we don't have reference frames */
885  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
886  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
887  goto end;
888  }
889  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
891  avctx->skip_frame >= AVDISCARD_ALL) {
892  goto end;
893  }
894 
895  if (s->next_p_frame_damaged) {
896  if (s->pict_type == AV_PICTURE_TYPE_B)
897  goto end;
898  else
899  s->next_p_frame_damaged = 0;
900  }
901 
902  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
903  goto err;
904  }
905 
909 
910  // process pulldown flags
912  // Pulldown flags are only valid when 'broadcast' has been set.
913  // So ticks_per_frame will be 2
914  if (v->rff) {
915  // repeat field
917  } else if (v->rptfrm) {
918  // repeat frames
919  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
920  }
921 
924 
925 #if FF_API_CAP_VDPAU
928  if (v->field_mode && buf_start_second_field) {
929  ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
930  ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
931  } else {
932  ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
933  }
934  } else
935 #endif
936  if (avctx->hwaccel) {
937  if (v->field_mode && buf_start_second_field) {
938  // decode first field
940  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
941  goto err;
942  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
943  goto err;
944  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
945  goto err;
946 
947  // decode second field
948  s->gb = slices[n_slices1 + 1].gb;
950  v->second_field = 1;
951  v->pic_header_flag = 0;
952  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
953  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
954  ret = AVERROR_INVALIDDATA;
955  goto err;
956  }
958 
959  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
960  goto err;
961  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
962  goto err;
963  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
964  goto err;
965  } else {
967  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
968  goto err;
969  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
970  goto err;
971  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
972  goto err;
973  }
974  } else {
975  int header_ret = 0;
976 
978 
979  v->bits = FFMIN(buf_size * 8, s->gb.size_in_bits);
980  v->end_mb_x = s->mb_width;
981  if (v->field_mode) {
982  s->current_picture.f->linesize[0] <<= 1;
983  s->current_picture.f->linesize[1] <<= 1;
984  s->current_picture.f->linesize[2] <<= 1;
985  s->linesize <<= 1;
986  s->uvlinesize <<= 1;
987  }
988  mb_height = s->mb_height >> v->field_mode;
989 
990  av_assert0 (mb_height > 0);
991 
992  for (i = 0; i <= n_slices; i++) {
993  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
994  if (v->field_mode <= 0) {
995  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
996  "picture boundary (%d >= %d)\n", i,
997  slices[i - 1].mby_start, mb_height);
998  continue;
999  }
1000  v->second_field = 1;
1001  av_assert0((s->mb_height & 1) == 0);
1002  v->blocks_off = s->b8_stride * (s->mb_height&~1);
1003  v->mb_off = s->mb_stride * s->mb_height >> 1;
1004  } else {
1005  v->second_field = 0;
1006  v->blocks_off = 0;
1007  v->mb_off = 0;
1008  }
1009  if (i) {
1010  v->pic_header_flag = 0;
1011  if (v->field_mode && i == n_slices1 + 2) {
1012  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1013  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1014  ret = AVERROR_INVALIDDATA;
1015  if (avctx->err_recognition & AV_EF_EXPLODE)
1016  goto err;
1017  continue;
1018  }
1019  } else if (get_bits1(&s->gb)) {
1020  v->pic_header_flag = 1;
1021  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1022  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1023  ret = AVERROR_INVALIDDATA;
1024  if (avctx->err_recognition & AV_EF_EXPLODE)
1025  goto err;
1026  continue;
1027  }
1028  }
1029  }
1030  if (header_ret < 0)
1031  continue;
1032  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1033  if (!v->field_mode || v->second_field)
1034  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1035  else {
1036  if (i >= n_slices) {
1037  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1038  continue;
1039  }
1040  s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1041  }
1042  if (s->end_mb_y <= s->start_mb_y) {
1043  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1044  continue;
1045  }
1046  if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1047  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1048  continue;
1049  }
1051  if (i != n_slices) {
1052  s->gb = slices[i].gb;
1053  v->bits = FFMIN(buf_size * 8, s->gb.size_in_bits);
1054  }
1055  }
1056  if (v->field_mode) {
1057  v->second_field = 0;
1058  s->current_picture.f->linesize[0] >>= 1;
1059  s->current_picture.f->linesize[1] >>= 1;
1060  s->current_picture.f->linesize[2] >>= 1;
1061  s->linesize >>= 1;
1062  s->uvlinesize >>= 1;
1064  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1065  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1066  }
1067  }
1068  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1069  get_bits_count(&s->gb), s->gb.size_in_bits);
1070 // if (get_bits_count(&s->gb) > buf_size * 8)
1071 // return -1;
1072  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1073  ret = AVERROR_INVALIDDATA;
1074  goto err;
1075  }
1076  if (!v->field_mode)
1077  ff_er_frame_end(&s->er);
1078  }
1079 
1080  ff_mpv_frame_end(s);
1081 
1082  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1083 image:
1084  avctx->width = avctx->coded_width = v->output_width;
1085  avctx->height = avctx->coded_height = v->output_height;
1086  if (avctx->skip_frame >= AVDISCARD_NONREF)
1087  goto end;
1088 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1089  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1090  goto err;
1091 #endif
1092  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1093  goto err;
1094  *got_frame = 1;
1095  } else {
1096  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1097  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1098  goto err;
1100  *got_frame = 1;
1101  } else if (s->last_picture_ptr) {
1102  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1103  goto err;
1105  *got_frame = 1;
1106  }
1107  }
1108 
1109 end:
1110  av_free(buf2);
1111  for (i = 0; i < n_slices; i++)
1112  av_free(slices[i].buf);
1113  av_free(slices);
1114  return buf_size;
1115 
1116 err:
1117  av_free(buf2);
1118  for (i = 0; i < n_slices; i++)
1119  av_free(slices[i].buf);
1120  av_free(slices);
1121  return ret;
1122 }
1123 
1124 
1125 static const AVProfile profiles[] = {
1126  { FF_PROFILE_VC1_SIMPLE, "Simple" },
1127  { FF_PROFILE_VC1_MAIN, "Main" },
1128  { FF_PROFILE_VC1_COMPLEX, "Complex" },
1129  { FF_PROFILE_VC1_ADVANCED, "Advanced" },
1130  { FF_PROFILE_UNKNOWN },
1131 };
1132 
1134 #if CONFIG_VC1_DXVA2_HWACCEL
1136 #endif
1137 #if CONFIG_VC1_D3D11VA_HWACCEL
1139 #endif
1140 #if CONFIG_VC1_VAAPI_HWACCEL
1142 #endif
1143 #if CONFIG_VC1_VDPAU_HWACCEL
1145 #endif
1148 };
1149 
1151  .name = "vc1",
1152  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1153  .type = AVMEDIA_TYPE_VIDEO,
1154  .id = AV_CODEC_ID_VC1,
1155  .priv_data_size = sizeof(VC1Context),
1156  .init = vc1_decode_init,
1157  .close = ff_vc1_decode_end,
1159  .flush = ff_mpeg_flush,
1160  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1161  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1162  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1163 };
1164 
1165 #if CONFIG_WMV3_DECODER
1166 AVCodec ff_wmv3_decoder = {
1167  .name = "wmv3",
1168  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1169  .type = AVMEDIA_TYPE_VIDEO,
1170  .id = AV_CODEC_ID_WMV3,
1171  .priv_data_size = sizeof(VC1Context),
1172  .init = vc1_decode_init,
1173  .close = ff_vc1_decode_end,
1175  .flush = ff_mpeg_flush,
1176  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1177  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1178  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1179 };
1180 #endif
1181 
1182 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1183 AVCodec ff_wmv3_vdpau_decoder = {
1184  .name = "wmv3_vdpau",
1185  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1186  .type = AVMEDIA_TYPE_VIDEO,
1187  .id = AV_CODEC_ID_WMV3,
1188  .priv_data_size = sizeof(VC1Context),
1189  .init = vc1_decode_init,
1190  .close = ff_vc1_decode_end,
1194  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1195 };
1196 #endif
1197 
1198 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1199 AVCodec ff_vc1_vdpau_decoder = {
1200  .name = "vc1_vdpau",
1201  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1202  .type = AVMEDIA_TYPE_VIDEO,
1203  .id = AV_CODEC_ID_VC1,
1204  .priv_data_size = sizeof(VC1Context),
1205  .init = vc1_decode_init,
1206  .close = ff_vc1_decode_end,
1210  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1211 };
1212 #endif
1213 
1214 #if CONFIG_WMV3IMAGE_DECODER
1215 AVCodec ff_wmv3image_decoder = {
1216  .name = "wmv3image",
1217  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1218  .type = AVMEDIA_TYPE_VIDEO,
1219  .id = AV_CODEC_ID_WMV3IMAGE,
1220  .priv_data_size = sizeof(VC1Context),
1221  .init = vc1_decode_init,
1222  .close = ff_vc1_decode_end,
1224  .capabilities = AV_CODEC_CAP_DR1,
1225  .flush = vc1_sprite_flush,
1226  .pix_fmts = (const enum AVPixelFormat[]) {
1229  },
1230 };
1231 #endif
1232 
1233 #if CONFIG_VC1IMAGE_DECODER
1234 AVCodec ff_vc1image_decoder = {
1235  .name = "vc1image",
1236  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1237  .type = AVMEDIA_TYPE_VIDEO,
1238  .id = AV_CODEC_ID_VC1IMAGE,
1239  .priv_data_size = sizeof(VC1Context),
1240  .init = vc1_decode_init,
1241  .close = ff_vc1_decode_end,
1243  .capabilities = AV_CODEC_CAP_DR1,
1244  .flush = vc1_sprite_flush,
1245  .pix_fmts = (const enum AVPixelFormat[]) {
1248  },
1249 };
1250 #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:1521
discard all frames except keyframes
Definition: avcodec.h:688
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:3650
BI type.
Definition: avutil.h:272
float v
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:171
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:160
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:1706
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:261
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:299
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:161
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:1790
#define avpriv_request_sample(...)
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:139
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:2247
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:362
int size
Definition: avcodec.h:1434
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:1732
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:689
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:3125
QpelDSPContext qdsp
Definition: mpegvideo.h:242
AVCodec.
Definition: avcodec.h:3482
#define FFALIGN(x, a)
Definition: common.h:97
uint8_t rff
Definition: vc1.h:311
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3236
int bits
Definition: vc1.h:179
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2932
#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:882
#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.
static const AVProfile profiles[]
Definition: vc1dec.c:1125
int matrix_coef
8bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:208
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
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:1583
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 AV_RB32
Definition: intreadwrite.h:130
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:201
#define FF_PROFILE_VC1_ADVANCED
Definition: avcodec.h:3174
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:90
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:780
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:366
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:3126
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1627
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:187
int16_t((* luma_mv)[2]
Definition: vc1.h:388
#define FF_API_CAP_VDPAU
Definition: version.h:95
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:34
MSMPEG4 data tables.
uint8_t * data
Definition: avcodec.h:1433
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:213
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:893
#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:112
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:367
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:136
ptrdiff_t size
Definition: opengl_enc.c:101
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:763
#define av_log(a,...)
#define transpose(x)
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:1822
#define FF_PROFILE_VC1_COMPLEX
Definition: avcodec.h:3173
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2911
#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:148
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
ERContext er
Definition: mpegvideo.h:553
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:418
int capabilities
Codec capabilities.
Definition: avcodec.h:3501
#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:1607
simple assert() macros that are a bit more flexible than ISO C assert().
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2949
#define PICT_TOP_FIELD
Definition: mpegutils.h:33
const char * name
Name of the codec implementation.
Definition: avcodec.h:3489
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:411
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:73
GetBitContext gb
Definition: mpegvideo.h:451
GLsizei count
Definition: opengl_enc.c:109
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1105
#define FFMAX(a, b)
Definition: common.h:90
Libavcodec external API header.
#define FF_PROFILE_VC1_MAIN
Definition: avcodec.h:3172
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:2759
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:849
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
AVCodec ff_vc1_decoder
Definition: vc1dec.c:1150
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3503
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:595
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2900
#define FFMIN(a, b)
Definition: common.h:92
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:399
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed b frames
Definition: mpegvideo.h:367
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:1691
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:191
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:58
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2226
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:323
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:632
int level
level
Definition: avcodec.h:3214
#define CONFIG_GRAY
Definition: config.h:485
MotionEstContext me
Definition: mpegvideo.h:290
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:1222
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
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
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:141
enum AVCodecID codec_id
Definition: avcodec.h:1529
BlockDSPContext bdsp
Definition: mpegvideo.h:233
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:199
int debug
debug
Definition: avcodec.h:2852
uint32_t * cbp_base
Definition: vc1.h:386
main external API structure.
Definition: avcodec.h:1512
uint8_t * is_intra
Definition: vc1.h:387
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:107
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1048
void * buf
Definition: avisynth_c.h:553
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1949
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:1628
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:305
int sprite_width
Definition: vc1.h:376
uint8_t * is_intra_base
Definition: vc1.h:387
int coded_height
Definition: avcodec.h:1706
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:298
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2240
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2233
struct AVFrame * f
Definition: mpegpicture.h:46
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:227
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:415
int context_initialized
Definition: mpegvideo.h:131
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:142
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:1179
#define CONFIG_VC1_VDPAU_DECODER
Definition: config.h:813
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:338
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:153
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:219
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:245
static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:630
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:465
#define FF_PROFILE_VC1_SIMPLE
Definition: avcodec.h:3171
uint8_t tff
Definition: vc1.h:311
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
qpel_mc_func(* qpel_avg)[16]
Definition: motion_est.h:91
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2853
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:138
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:543
MpegEncContext s
Definition: vc1.h:174
MpegEncContext.
Definition: mpegvideo.h:88
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:190
struct AVCodecContext * avctx
Definition: mpegvideo.h:105
VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstrea...
Definition: pixfmt.h:113
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:521
discard all non reference
Definition: avcodec.h:685
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:67
Y , 8bpp.
Definition: pixfmt.h:75
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:137
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1133
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:169
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:189
Bi-dir predicted.
Definition: avutil.h:268
AVProfile.
Definition: avcodec.h:3470
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:636
void * priv_data
Definition: avcodec.h:1554
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:514
#define PICT_FRAME
Definition: mpegutils.h:35
int picture_structure
Definition: mpegvideo.h:463
#define av_free(p)
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:372
AVFrame * sprite_output_frame
Definition: vc1.h:375
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1414
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:237
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:272
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:95
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:3664
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3675
void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf, int buf_size)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:65
This structure stores compressed data.
Definition: avcodec.h:1410
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:857
VC1DSPContext vc1dsp
Definition: vc1.h:177
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