FFmpeg  4.3.9
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 "hwconfig.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] +
200  v->sprite_output_frame->linesize[plane] * row;
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_mallocz(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_mallocz(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 AVERROR_INVALIDDATA;
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  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
454  avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
455  return AVERROR_PATCHWELCOME;
456  }
457 
458  count = avctx->extradata_size*8 - get_bits_count(&gb);
459  if (count > 0) {
460  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
461  count, get_bits_long(&gb, FFMIN(count, 32)));
462  } else if (count < 0) {
463  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
464  }
465  } else { // VC1/WVC1/WVP2
466  const uint8_t *start = avctx->extradata;
467  uint8_t *end = avctx->extradata + avctx->extradata_size;
468  const uint8_t *next;
469  int size, buf2_size;
470  uint8_t *buf2 = NULL;
471  int seq_initialized = 0, ep_initialized = 0;
472 
473  if (avctx->extradata_size < 16) {
474  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
475  return AVERROR_INVALIDDATA;
476  }
477 
479  if (!buf2)
480  return AVERROR(ENOMEM);
481 
482  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
483  next = start;
484  for (; next < end; start = next) {
485  next = find_next_marker(start + 4, end);
486  size = next - start - 4;
487  if (size <= 0)
488  continue;
489  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
490  init_get_bits(&gb, buf2, buf2_size * 8);
491  switch (AV_RB32(start)) {
492  case VC1_CODE_SEQHDR:
493  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
494  av_free(buf2);
495  return ret;
496  }
497  seq_initialized = 1;
498  break;
499  case VC1_CODE_ENTRYPOINT:
500  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
501  av_free(buf2);
502  return ret;
503  }
504  ep_initialized = 1;
505  break;
506  }
507  }
508  av_free(buf2);
509  if (!seq_initialized || !ep_initialized) {
510  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
511  return AVERROR_INVALIDDATA;
512  }
513  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
514  }
515 
516  avctx->profile = v->profile;
517  if (v->profile == PROFILE_ADVANCED)
518  avctx->level = v->level;
519 
520  if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
521  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
522  else {
523  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
524  if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
525  avctx->color_range = AVCOL_RANGE_MPEG;
526  }
527 
528  // ensure static VLC tables are initialized
529  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
530  return ret;
531  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
532  return ret;
533  // Hack to ensure the above functions will be called
534  // again once we know all necessary settings.
535  // That this is necessary might indicate a bug.
536  ff_vc1_decode_end(avctx);
537 
538  ff_blockdsp_init(&s->bdsp, avctx);
540  ff_qpeldsp_init(&s->qdsp);
541 
542  // Must happen after calling ff_vc1_decode_end
543  // to avoid de-allocating the sprite_output_frame
545  if (!v->sprite_output_frame)
546  return AVERROR(ENOMEM);
547 
548  avctx->has_b_frames = !!avctx->max_b_frames;
549 
550  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
551  avctx->color_primaries = v->color_prim;
552  if (v->transfer_char == 1 || v->transfer_char == 7)
553  avctx->color_trc = v->transfer_char;
554  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
555  avctx->colorspace = v->matrix_coef;
556 
557  s->mb_width = (avctx->coded_width + 15) >> 4;
558  s->mb_height = (avctx->coded_height + 15) >> 4;
559 
560  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
562  } else {
563  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
564  v->left_blk_sh = 3;
565  v->top_blk_sh = 0;
566  }
567 
568  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
569  v->sprite_width = avctx->coded_width;
570  v->sprite_height = avctx->coded_height;
571 
572  avctx->coded_width = avctx->width = v->output_width;
573  avctx->coded_height = avctx->height = v->output_height;
574 
575  // prevent 16.16 overflows
576  if (v->sprite_width > 1 << 14 ||
577  v->sprite_height > 1 << 14 ||
578  v->output_width > 1 << 14 ||
579  v->output_height > 1 << 14) {
580  ret = AVERROR_INVALIDDATA;
581  goto error;
582  }
583 
584  if ((v->sprite_width&1) || (v->sprite_height&1)) {
585  avpriv_request_sample(avctx, "odd sprites support");
586  ret = AVERROR_PATCHWELCOME;
587  goto error;
588  }
589  }
590  return 0;
591 error:
593  return ret;
594 }
595 
596 /** Close a VC1/WMV3 decoder
597  * @warning Initial try at using MpegEncContext stuff
598  */
600 {
601  VC1Context *v = avctx->priv_data;
602  int i;
603 
605 
606  for (i = 0; i < 4; i++)
607  av_freep(&v->sr_rows[i >> 1][i & 1]);
608  av_freep(&v->hrd_rate);
609  av_freep(&v->hrd_buffer);
610  ff_mpv_common_end(&v->s);
611  memset(v->s.block_index, 0, sizeof(v->s.block_index));
615  av_freep(&v->fieldtx_plane);
616  av_freep(&v->acpred_plane);
618  av_freep(&v->mb_type_base);
620  av_freep(&v->mv_f_base);
622  av_freep(&v->block);
623  av_freep(&v->cbp_base);
624  av_freep(&v->ttblk_base);
625  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
626  av_freep(&v->luma_mv_base);
628  return 0;
629 }
630 
631 
632 /** Decode a VC1/WMV3 frame
633  * @todo TODO: Handle VC-1 IDUs (Transport level?)
634  */
635 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
636  int *got_frame, AVPacket *avpkt)
637 {
638  const uint8_t *buf = avpkt->data;
639  int buf_size = avpkt->size, n_slices = 0, i, ret;
640  VC1Context *v = avctx->priv_data;
641  MpegEncContext *s = &v->s;
642  AVFrame *pict = data;
643  uint8_t *buf2 = NULL;
644  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
645  int mb_height, n_slices1=-1;
646  struct {
647  uint8_t *buf;
648  GetBitContext gb;
649  int mby_start;
650  const uint8_t *rawbuf;
651  int raw_size;
652  } *slices = NULL, *tmp;
653 
654  v->second_field = 0;
655 
657  s->low_delay = 1;
658 
659  /* no supplementary picture */
660  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
661  /* special case for last picture */
662  if (s->low_delay == 0 && s->next_picture_ptr) {
663  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
664  return ret;
665  s->next_picture_ptr = NULL;
666 
667  *got_frame = 1;
668  }
669 
670  return buf_size;
671  }
672 
673  //for advanced profile we may need to parse and unescape data
674  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
675  int buf_size2 = 0;
676  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
677  if (!buf2)
678  return AVERROR(ENOMEM);
679 
680  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
681  const uint8_t *start, *end, *next;
682  int size;
683 
684  next = buf;
685  for (start = buf, end = buf + buf_size; next < end; start = next) {
686  next = find_next_marker(start + 4, end);
687  size = next - start - 4;
688  if (size <= 0) continue;
689  switch (AV_RB32(start)) {
690  case VC1_CODE_FRAME:
691  if (avctx->hwaccel)
692  buf_start = start;
693  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
694  break;
695  case VC1_CODE_FIELD: {
696  int buf_size3;
697  if (avctx->hwaccel)
698  buf_start_second_field = start;
699  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
700  if (!tmp) {
701  ret = AVERROR(ENOMEM);
702  goto err;
703  }
704  slices = tmp;
705  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
706  if (!slices[n_slices].buf) {
707  ret = AVERROR(ENOMEM);
708  goto err;
709  }
710  buf_size3 = vc1_unescape_buffer(start + 4, size,
711  slices[n_slices].buf);
712  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
713  buf_size3 << 3);
714  slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
715  slices[n_slices].rawbuf = start;
716  slices[n_slices].raw_size = size + 4;
717  n_slices1 = n_slices - 1; // index of the last slice of the first field
718  n_slices++;
719  break;
720  }
721  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
722  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
723  init_get_bits(&s->gb, buf2, buf_size2 * 8);
724  ff_vc1_decode_entry_point(avctx, v, &s->gb);
725  break;
726  case VC1_CODE_SLICE: {
727  int buf_size3;
728  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
729  if (!tmp) {
730  ret = AVERROR(ENOMEM);
731  goto err;
732  }
733  slices = tmp;
734  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
735  if (!slices[n_slices].buf) {
736  ret = AVERROR(ENOMEM);
737  goto err;
738  }
739  buf_size3 = vc1_unescape_buffer(start + 4, size,
740  slices[n_slices].buf);
741  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
742  buf_size3 << 3);
743  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
744  slices[n_slices].rawbuf = start;
745  slices[n_slices].raw_size = size + 4;
746  n_slices++;
747  break;
748  }
749  }
750  }
751  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
752  const uint8_t *divider;
753  int buf_size3;
754 
755  divider = find_next_marker(buf, buf + buf_size);
756  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
757  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
758  ret = AVERROR_INVALIDDATA;
759  goto err;
760  } else { // found field marker, unescape second field
761  if (avctx->hwaccel)
762  buf_start_second_field = divider;
763  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
764  if (!tmp) {
765  ret = AVERROR(ENOMEM);
766  goto err;
767  }
768  slices = tmp;
769  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
770  if (!slices[n_slices].buf) {
771  ret = AVERROR(ENOMEM);
772  goto err;
773  }
774  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
775  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
776  buf_size3 << 3);
777  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
778  slices[n_slices].rawbuf = divider;
779  slices[n_slices].raw_size = buf + buf_size - divider;
780  n_slices1 = n_slices - 1;
781  n_slices++;
782  }
783  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
784  } else {
785  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
786  }
787  init_get_bits(&s->gb, buf2, buf_size2*8);
788  } else
789  init_get_bits(&s->gb, buf, buf_size*8);
790 
791  if (v->res_sprite) {
792  v->new_sprite = !get_bits1(&s->gb);
793  v->two_sprites = get_bits1(&s->gb);
794  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
795  we're using the sprite compositor. These are intentionally kept separate
796  so you can get the raw sprites by using the wmv3 decoder for WMVP or
797  the vc1 one for WVP2 */
798  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
799  if (v->new_sprite) {
800  // switch AVCodecContext parameters to those of the sprites
801  avctx->width = avctx->coded_width = v->sprite_width;
802  avctx->height = avctx->coded_height = v->sprite_height;
803  } else {
804  goto image;
805  }
806  }
807  }
808 
809  if (s->context_initialized &&
810  (s->width != avctx->coded_width ||
811  s->height != avctx->coded_height)) {
812  ff_vc1_decode_end(avctx);
813  }
814 
815  if (!s->context_initialized) {
816  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
817  goto err;
818  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
820  goto err;
821  }
822 
823  s->low_delay = !avctx->has_b_frames || v->res_sprite;
824 
825  if (v->profile == PROFILE_ADVANCED) {
826  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
827  ret = AVERROR_INVALIDDATA;
828  goto err;
829  }
830  s->h_edge_pos = avctx->coded_width;
831  s->v_edge_pos = avctx->coded_height;
832  }
833  }
834 
835  // do parse frame header
836  v->pic_header_flag = 0;
837  v->first_pic_header_flag = 1;
838  if (v->profile < PROFILE_ADVANCED) {
839  if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
840  goto err;
841  }
842  } else {
843  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
844  goto err;
845  }
846  }
847  v->first_pic_header_flag = 0;
848 
849  if (avctx->debug & FF_DEBUG_PICT_INFO)
850  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
851 
852  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
853  && s->pict_type != AV_PICTURE_TYPE_I) {
854  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
855  ret = AVERROR_INVALIDDATA;
856  goto err;
857  }
858  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
859  && v->field_mode) {
860  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
861  ret = AVERROR_INVALIDDATA;
862  goto err;
863  }
864  if ((s->mb_height >> v->field_mode) == 0) {
865  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
866  ret = AVERROR_INVALIDDATA;
867  goto err;
868  }
869 
870  // for skipping the frame
873 
874  /* skip B-frames if we don't have reference frames */
875  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
876  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
877  goto end;
878  }
879  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
881  avctx->skip_frame >= AVDISCARD_ALL) {
882  goto end;
883  }
884 
885  if (s->next_p_frame_damaged) {
886  if (s->pict_type == AV_PICTURE_TYPE_B)
887  goto end;
888  else
889  s->next_p_frame_damaged = 0;
890  }
891 
892  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
893  goto err;
894  }
895 
899 
900  // process pulldown flags
902  // Pulldown flags are only valid when 'broadcast' has been set.
903  // So ticks_per_frame will be 2
904  if (v->rff) {
905  // repeat field
907  } else if (v->rptfrm) {
908  // repeat frames
909  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
910  }
911 
914 
915  if (avctx->hwaccel) {
916  s->mb_y = 0;
917  if (v->field_mode && buf_start_second_field) {
918  // decode first field
920  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
921  goto err;
922 
923  if (n_slices1 == -1) {
924  // no slices, decode the field as-is
925  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
926  goto err;
927  } else {
928  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
929  goto err;
930 
931  for (i = 0 ; i < n_slices1 + 1; i++) {
932  s->gb = slices[i].gb;
933  s->mb_y = slices[i].mby_start;
934 
935  v->pic_header_flag = get_bits1(&s->gb);
936  if (v->pic_header_flag) {
937  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
938  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
939  ret = AVERROR_INVALIDDATA;
940  if (avctx->err_recognition & AV_EF_EXPLODE)
941  goto err;
942  continue;
943  }
944  }
945 
946  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
947  goto err;
948  }
949  }
950 
951  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
952  goto err;
953 
954  // decode second field
955  s->gb = slices[n_slices1 + 1].gb;
956  s->mb_y = slices[n_slices1 + 1].mby_start;
958  v->second_field = 1;
959  v->pic_header_flag = 0;
960  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
961  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
962  ret = AVERROR_INVALIDDATA;
963  goto err;
964  }
966 
967  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
968  goto err;
969 
970  if (n_slices - n_slices1 == 2) {
971  // no slices, decode the field as-is
972  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
973  goto err;
974  } else {
975  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
976  goto err;
977 
978  for (i = n_slices1 + 2; i < n_slices; i++) {
979  s->gb = slices[i].gb;
980  s->mb_y = slices[i].mby_start;
981 
982  v->pic_header_flag = get_bits1(&s->gb);
983  if (v->pic_header_flag) {
984  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
985  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
986  ret = AVERROR_INVALIDDATA;
987  if (avctx->err_recognition & AV_EF_EXPLODE)
988  goto err;
989  continue;
990  }
991  }
992 
993  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
994  goto err;
995  }
996  }
997 
998  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
999  goto err;
1000  } else {
1002  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1003  goto err;
1004 
1005  if (n_slices == 0) {
1006  // no slices, decode the frame as-is
1007  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1008  goto err;
1009  } else {
1010  // decode the frame part as the first slice
1011  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1012  goto err;
1013 
1014  // and process the slices as additional slices afterwards
1015  for (i = 0 ; i < n_slices; i++) {
1016  s->gb = slices[i].gb;
1017  s->mb_y = slices[i].mby_start;
1018 
1019  v->pic_header_flag = get_bits1(&s->gb);
1020  if (v->pic_header_flag) {
1021  if (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 ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1031  goto err;
1032  }
1033  }
1034  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1035  goto err;
1036  }
1037  } else {
1038  int header_ret = 0;
1039 
1041 
1042  v->end_mb_x = s->mb_width;
1043  if (v->field_mode) {
1044  s->current_picture.f->linesize[0] <<= 1;
1045  s->current_picture.f->linesize[1] <<= 1;
1046  s->current_picture.f->linesize[2] <<= 1;
1047  s->linesize <<= 1;
1048  s->uvlinesize <<= 1;
1049  }
1050  mb_height = s->mb_height >> v->field_mode;
1051 
1052  av_assert0 (mb_height > 0);
1053 
1054  for (i = 0; i <= n_slices; i++) {
1055  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1056  if (v->field_mode <= 0) {
1057  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1058  "picture boundary (%d >= %d)\n", i,
1059  slices[i - 1].mby_start, mb_height);
1060  continue;
1061  }
1062  v->second_field = 1;
1063  av_assert0((s->mb_height & 1) == 0);
1064  v->blocks_off = s->b8_stride * (s->mb_height&~1);
1065  v->mb_off = s->mb_stride * s->mb_height >> 1;
1066  } else {
1067  v->second_field = 0;
1068  v->blocks_off = 0;
1069  v->mb_off = 0;
1070  }
1071  if (i) {
1072  v->pic_header_flag = 0;
1073  if (v->field_mode && i == n_slices1 + 2) {
1074  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1075  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1076  ret = AVERROR_INVALIDDATA;
1077  if (avctx->err_recognition & AV_EF_EXPLODE)
1078  goto err;
1079  continue;
1080  }
1081  } else if (get_bits1(&s->gb)) {
1082  v->pic_header_flag = 1;
1083  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1084  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1085  ret = AVERROR_INVALIDDATA;
1086  if (avctx->err_recognition & AV_EF_EXPLODE)
1087  goto err;
1088  continue;
1089  }
1090  }
1091  }
1092  if (header_ret < 0)
1093  continue;
1094  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1095  if (!v->field_mode || v->second_field)
1096  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1097  else {
1098  if (i >= n_slices) {
1099  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1100  continue;
1101  }
1102  s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1103  }
1104  if (s->end_mb_y <= s->start_mb_y) {
1105  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1106  continue;
1107  }
1108  if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1109  (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1110  !v->cbpcy_vlc) {
1111  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1112  continue;
1113  }
1115  if (i != n_slices) {
1116  s->gb = slices[i].gb;
1117  }
1118  }
1119  if (v->field_mode) {
1120  v->second_field = 0;
1121  s->current_picture.f->linesize[0] >>= 1;
1122  s->current_picture.f->linesize[1] >>= 1;
1123  s->current_picture.f->linesize[2] >>= 1;
1124  s->linesize >>= 1;
1125  s->uvlinesize >>= 1;
1127  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1128  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1129  }
1130  }
1131  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1132  get_bits_count(&s->gb), s->gb.size_in_bits);
1133 // if (get_bits_count(&s->gb) > buf_size * 8)
1134 // return -1;
1135  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1136  ret = AVERROR_INVALIDDATA;
1137  goto err;
1138  }
1139  if ( !v->field_mode
1140  && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1141  && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1142  ff_er_frame_end(&s->er);
1143  }
1144 
1145  ff_mpv_frame_end(s);
1146 
1147  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1148 image:
1149  avctx->width = avctx->coded_width = v->output_width;
1150  avctx->height = avctx->coded_height = v->output_height;
1151  if (avctx->skip_frame >= AVDISCARD_NONREF)
1152  goto end;
1153 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1154  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1155  goto err;
1156 #endif
1157  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1158  goto err;
1159  *got_frame = 1;
1160  } else {
1161  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1162  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1163  goto err;
1164  if (!v->field_mode)
1166  *got_frame = 1;
1167  } else if (s->last_picture_ptr) {
1168  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1169  goto err;
1170  if (!v->field_mode)
1172  *got_frame = 1;
1173  }
1174  }
1175 
1176 end:
1177  av_free(buf2);
1178  for (i = 0; i < n_slices; i++)
1179  av_free(slices[i].buf);
1180  av_free(slices);
1181  return buf_size;
1182 
1183 err:
1184  av_free(buf2);
1185  for (i = 0; i < n_slices; i++)
1186  av_free(slices[i].buf);
1187  av_free(slices);
1188  return ret;
1189 }
1190 
1191 
1193 #if CONFIG_VC1_DXVA2_HWACCEL
1195 #endif
1196 #if CONFIG_VC1_D3D11VA_HWACCEL
1199 #endif
1200 #if CONFIG_VC1_NVDEC_HWACCEL
1202 #endif
1203 #if CONFIG_VC1_VAAPI_HWACCEL
1205 #endif
1206 #if CONFIG_VC1_VDPAU_HWACCEL
1208 #endif
1211 };
1212 
1214  .name = "vc1",
1215  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1216  .type = AVMEDIA_TYPE_VIDEO,
1217  .id = AV_CODEC_ID_VC1,
1218  .priv_data_size = sizeof(VC1Context),
1219  .init = vc1_decode_init,
1220  .close = ff_vc1_decode_end,
1222  .flush = ff_mpeg_flush,
1223  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1224  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1225  .hw_configs = (const AVCodecHWConfigInternal*[]) {
1226 #if CONFIG_VC1_DXVA2_HWACCEL
1227  HWACCEL_DXVA2(vc1),
1228 #endif
1229 #if CONFIG_VC1_D3D11VA_HWACCEL
1230  HWACCEL_D3D11VA(vc1),
1231 #endif
1232 #if CONFIG_VC1_D3D11VA2_HWACCEL
1233  HWACCEL_D3D11VA2(vc1),
1234 #endif
1235 #if CONFIG_VC1_NVDEC_HWACCEL
1236  HWACCEL_NVDEC(vc1),
1237 #endif
1238 #if CONFIG_VC1_VAAPI_HWACCEL
1239  HWACCEL_VAAPI(vc1),
1240 #endif
1241 #if CONFIG_VC1_VDPAU_HWACCEL
1242  HWACCEL_VDPAU(vc1),
1243 #endif
1244  NULL
1245  },
1247 };
1248 
1249 #if CONFIG_WMV3_DECODER
1251  .name = "wmv3",
1252  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1253  .type = AVMEDIA_TYPE_VIDEO,
1254  .id = AV_CODEC_ID_WMV3,
1255  .priv_data_size = sizeof(VC1Context),
1256  .init = vc1_decode_init,
1257  .close = ff_vc1_decode_end,
1259  .flush = ff_mpeg_flush,
1260  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1261  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1262  .hw_configs = (const AVCodecHWConfigInternal*[]) {
1263 #if CONFIG_WMV3_DXVA2_HWACCEL
1264  HWACCEL_DXVA2(wmv3),
1265 #endif
1266 #if CONFIG_WMV3_D3D11VA_HWACCEL
1267  HWACCEL_D3D11VA(wmv3),
1268 #endif
1269 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1270  HWACCEL_D3D11VA2(wmv3),
1271 #endif
1272 #if CONFIG_WMV3_NVDEC_HWACCEL
1273  HWACCEL_NVDEC(wmv3),
1274 #endif
1275 #if CONFIG_WMV3_VAAPI_HWACCEL
1276  HWACCEL_VAAPI(wmv3),
1277 #endif
1278 #if CONFIG_WMV3_VDPAU_HWACCEL
1279  HWACCEL_VDPAU(wmv3),
1280 #endif
1281  NULL
1282  },
1284 };
1285 #endif
1286 
1287 #if CONFIG_WMV3IMAGE_DECODER
1289  .name = "wmv3image",
1290  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1291  .type = AVMEDIA_TYPE_VIDEO,
1292  .id = AV_CODEC_ID_WMV3IMAGE,
1293  .priv_data_size = sizeof(VC1Context),
1294  .init = vc1_decode_init,
1295  .close = ff_vc1_decode_end,
1297  .capabilities = AV_CODEC_CAP_DR1,
1298  .flush = vc1_sprite_flush,
1299  .pix_fmts = (const enum AVPixelFormat[]) {
1301  AV_PIX_FMT_NONE
1302  },
1303 };
1304 #endif
1305 
1306 #if CONFIG_VC1IMAGE_DECODER
1308  .name = "vc1image",
1309  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1310  .type = AVMEDIA_TYPE_VIDEO,
1311  .id = AV_CODEC_ID_VC1IMAGE,
1312  .priv_data_size = sizeof(VC1Context),
1313  .init = vc1_decode_init,
1314  .close = ff_vc1_decode_end,
1316  .capabilities = AV_CODEC_CAP_DR1,
1317  .flush = vc1_sprite_flush,
1318  .pix_fmts = (const enum AVPixelFormat[]) {
1320  AV_PIX_FMT_NONE
1321  },
1322 };
1323 #endif
int color_prim
8 bits, chroma coordinates of the color primaries
Definition: vc1.h:204
in the bitstream is reported as 00b
Definition: vc1.h:149
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:1279
const struct AVCodec * codec
Definition: avcodec.h:535
discard all frames except keyframes
Definition: avcodec.h:235
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:384
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
The VC1 Context.
Definition: vc1.h:173
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
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:349
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
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:786
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:599
#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:1161
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:442
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
int size
Definition: packet.h:356
int transfer_char
8 bits, Opto-electronic transfer characteristics
Definition: vc1.h:205
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:736
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1192
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition: vc1.h:237
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:262
discard all
Definition: avcodec.h:236
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:349
int sprite_height
Definition: vc1.h:380
static void error(const char *err)
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:397
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1694
int profile
profile
Definition: avcodec.h:1863
QpelDSPContext qdsp
Definition: mpegvideo.h:235
AVCodec.
Definition: codec.h:190
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:71
uint8_t rff
Definition: vc1.h:310
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2008
#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: codec.h:75
#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:320
VC-1 tables.
int bi_type
Definition: vc1.h:385
int matrix_coef
8 bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:206
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
int first_pic_header_flag
Definition: vc1.h:367
uint16_t * hrd_rate
Definition: vc1.h:325
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1589
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1616
#define f(width, name)
Definition: cbs_vp9.c:255
#define AV_RB32
Definition: intreadwrite.h:130
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:199
int second_field
Definition: vc1.h:353
int n_allocated_blks
Definition: vc1.h:389
qpel_mc_func(* qpel_put)[16]
Definition: motion_est.h:91
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:325
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:444
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
int16_t((* luma_mv)[2]
Definition: vc1.h:392
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...
Definition: vc1.h:216
const char data[16]
Definition: mxf.c:91
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
MSMPEG4 data tables.
uint8_t * data
Definition: packet.h:355
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:286
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:447
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
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:322
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
#define FFALIGN(x, a)
Definition: macros.h:48
AVCodec ff_wmv3_decoder
#define av_log(a,...)
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:79
int16_t(* block)[6][64]
Definition: vc1.h:388
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#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:816
#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:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
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:350
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
simple assert() macros that are a bit more flexible than ISO C assert().
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:3026
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
const char * name
Name of the codec implementation.
Definition: codec.h:197
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
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1138
#define FFMAX(a, b)
Definition: common.h:94
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:348
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2312
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:850
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: codec.h:211
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:383
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1659
#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:348
#define width
int field_mode
1 for interlaced field pictures
Definition: vc1.h:351
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:699
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
int mb_off
Definition: vc1.h:363
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:1140
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:626
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:1986
#define CONFIG_GRAY
Definition: config.h:550
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:1670
HW acceleration through CUDA.
Definition: pixfmt.h:235
uint32_t * cbp
Definition: vc1.h:390
int left_blk_sh
Definition: vc1.h:238
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:67
int16_t(* luma_mv_base)[2]
Definition: vc1.h:392
uint8_t * fieldtx_plane
Definition: vc1.h:345
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
int * ttblk_base
Definition: vc1.h:257
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:282
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition: vc1.h:381
#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:181
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:238
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:2515
enum AVCodecID codec_id
Definition: avcodec.h:536
BlockDSPContext bdsp
Definition: mpegvideo.h:226
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
#define abs(x)
Definition: cuda_runtime.h:35
int debug
debug
Definition: avcodec.h:1615
uint32_t * cbp_base
Definition: vc1.h:390
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:526
uint8_t * is_intra
Definition: vc1.h:391
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:1854
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1444
int extradata_size
Definition: avcodec.h:628
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int sprite_width
Definition: vc1.h:380
uint8_t * is_intra_base
Definition: vc1.h:391
int coded_height
Definition: avcodec.h:714
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
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
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
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:1212
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:285
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:1213
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:284
int blocks_off
Definition: vc1.h:363
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2504
uint8_t tff
Definition: vc1.h:310
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
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:534
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:2476
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:125
discard all non reference
Definition: avcodec.h:232
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:380
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:307
static double c[64]
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:185
int pic_header_flag
Definition: vc1.h:368
int * ttblk
Transform type at the block level.
Definition: vc1.h:257
#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:215
void * priv_data
Definition: avcodec.h:553
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:508
#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:452
AVFrame * sprite_output_frame
Definition: vc1.h:379
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1436
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
uint8_t zzi_8x8[64]
Definition: vc1.h:347
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:310
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:378
H264ChromaContext h264chroma
Definition: vc1.h:176
int level
Advanced Profile.
Definition: vc1.h:195
#define av_freep(p)
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:377
uint8_t * mv_f_next[2]
Definition: vc1.h:350
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:378
uint8_t * mb_type[3]
Definition: vc1.h:262
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:325
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:332
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: codec.h:50
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:635
int output_height
Definition: vc1.h:380
static uint8_t tmp[11]
Definition: aes_ctr.c:26