FFmpeg  4.4.4
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_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
348  if (!v->ttblk_base)
349  goto error;
350  v->ttblk = v->ttblk_base + 2 * s->mb_stride;
351  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
352  if (!v->is_intra_base)
353  goto error;
354  v->is_intra = v->is_intra_base + 2 * s->mb_stride;
355  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
356  if (!v->luma_mv_base)
357  goto error;
358  v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
359 
360  /* allocate block type info in that way so it could be used with s->block_index[] */
361  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362  if (!v->mb_type_base)
363  goto error;
364  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
365  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
367 
368  /* allocate memory to store block level MV info */
369  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370  if (!v->blk_mv_type_base)
371  goto error;
372  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
373  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
374  if (!v->mv_f_base)
375  goto error;
376  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
377  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379  if (!v->mv_f_next_base)
380  goto error;
381  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
382  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
383 
384  if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
385  for (i = 0; i < 4; i++)
386  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
387  goto error;
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:
399  ff_vc1_decode_end(s->avctx);
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  avctx->has_b_frames = !!avctx->max_b_frames;
543 
544  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
545  avctx->color_primaries = v->color_prim;
546  if (v->transfer_char == 1 || v->transfer_char == 7)
547  avctx->color_trc = v->transfer_char;
548  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
549  avctx->colorspace = v->matrix_coef;
550 
551  s->mb_width = (avctx->coded_width + 15) >> 4;
552  s->mb_height = (avctx->coded_height + 15) >> 4;
553 
554  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
556  } else {
557  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
558  v->left_blk_sh = 3;
559  v->top_blk_sh = 0;
560  }
561 
562  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
563  v->sprite_width = avctx->coded_width;
564  v->sprite_height = avctx->coded_height;
565 
566  avctx->coded_width = avctx->width = v->output_width;
567  avctx->coded_height = avctx->height = v->output_height;
568 
569  // prevent 16.16 overflows
570  if (v->sprite_width > 1 << 14 ||
571  v->sprite_height > 1 << 14 ||
572  v->output_width > 1 << 14 ||
573  v->output_height > 1 << 14) {
574  return AVERROR_INVALIDDATA;
575  }
576 
577  if ((v->sprite_width&1) || (v->sprite_height&1)) {
578  avpriv_request_sample(avctx, "odd sprites support");
579  return AVERROR_PATCHWELCOME;
580  }
581  }
582  return 0;
583 }
584 
585 /** Close a VC1/WMV3 decoder
586  * @warning Initial try at using MpegEncContext stuff
587  */
589 {
590  VC1Context *v = avctx->priv_data;
591  int i;
592 
594 
595  for (i = 0; i < 4; i++)
596  av_freep(&v->sr_rows[i >> 1][i & 1]);
597  av_freep(&v->hrd_rate);
598  av_freep(&v->hrd_buffer);
599  ff_mpv_common_end(&v->s);
603  av_freep(&v->fieldtx_plane);
604  av_freep(&v->acpred_plane);
606  av_freep(&v->mb_type_base);
608  av_freep(&v->mv_f_base);
610  av_freep(&v->block);
611  av_freep(&v->cbp_base);
612  av_freep(&v->ttblk_base);
613  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
614  av_freep(&v->luma_mv_base);
616  return 0;
617 }
618 
619 
620 /** Decode a VC1/WMV3 frame
621  * @todo TODO: Handle VC-1 IDUs (Transport level?)
622  */
623 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
624  int *got_frame, AVPacket *avpkt)
625 {
626  const uint8_t *buf = avpkt->data;
627  int buf_size = avpkt->size, n_slices = 0, i, ret;
628  VC1Context *v = avctx->priv_data;
629  MpegEncContext *s = &v->s;
630  AVFrame *pict = data;
631  uint8_t *buf2 = NULL;
632  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
633  int mb_height, n_slices1=-1;
634  struct {
635  uint8_t *buf;
636  GetBitContext gb;
637  int mby_start;
638  const uint8_t *rawbuf;
639  int raw_size;
640  } *slices = NULL, *tmp;
641 
642  v->second_field = 0;
643 
644  if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
645  s->low_delay = 1;
646 
647  /* no supplementary picture */
648  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
649  /* special case for last picture */
650  if (s->low_delay == 0 && s->next_picture_ptr) {
651  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
652  return ret;
653  s->next_picture_ptr = NULL;
654 
655  *got_frame = 1;
656  }
657 
658  return buf_size;
659  }
660 
661  //for advanced profile we may need to parse and unescape data
662  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
663  int buf_size2 = 0;
664  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
665  if (!buf2)
666  return AVERROR(ENOMEM);
667 
668  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
669  const uint8_t *start, *end, *next;
670  int size;
671 
672  next = buf;
673  for (start = buf, end = buf + buf_size; next < end; start = next) {
674  next = find_next_marker(start + 4, end);
675  size = next - start - 4;
676  if (size <= 0) continue;
677  switch (AV_RB32(start)) {
678  case VC1_CODE_FRAME:
679  if (avctx->hwaccel)
680  buf_start = start;
681  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
682  break;
683  case VC1_CODE_FIELD: {
684  int buf_size3;
685  if (avctx->hwaccel)
686  buf_start_second_field = start;
687  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
688  if (!tmp) {
689  ret = AVERROR(ENOMEM);
690  goto err;
691  }
692  slices = tmp;
693  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
694  if (!slices[n_slices].buf) {
695  ret = AVERROR(ENOMEM);
696  goto err;
697  }
698  buf_size3 = vc1_unescape_buffer(start + 4, size,
699  slices[n_slices].buf);
700  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
701  buf_size3 << 3);
702  slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
703  slices[n_slices].rawbuf = start;
704  slices[n_slices].raw_size = size + 4;
705  n_slices1 = n_slices - 1; // index of the last slice of the first field
706  n_slices++;
707  break;
708  }
709  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
710  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
711  init_get_bits(&s->gb, buf2, buf_size2 * 8);
712  ff_vc1_decode_entry_point(avctx, v, &s->gb);
713  break;
714  case VC1_CODE_SLICE: {
715  int buf_size3;
716  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
717  if (!tmp) {
718  ret = AVERROR(ENOMEM);
719  goto err;
720  }
721  slices = tmp;
722  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
723  if (!slices[n_slices].buf) {
724  ret = AVERROR(ENOMEM);
725  goto err;
726  }
727  buf_size3 = vc1_unescape_buffer(start + 4, size,
728  slices[n_slices].buf);
729  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
730  buf_size3 << 3);
731  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
732  slices[n_slices].rawbuf = start;
733  slices[n_slices].raw_size = size + 4;
734  n_slices++;
735  break;
736  }
737  }
738  }
739  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
740  const uint8_t *divider;
741  int buf_size3;
742 
743  divider = find_next_marker(buf, buf + buf_size);
744  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
745  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
746  ret = AVERROR_INVALIDDATA;
747  goto err;
748  } else { // found field marker, unescape second field
749  if (avctx->hwaccel)
750  buf_start_second_field = divider;
751  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
752  if (!tmp) {
753  ret = AVERROR(ENOMEM);
754  goto err;
755  }
756  slices = tmp;
757  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
758  if (!slices[n_slices].buf) {
759  ret = AVERROR(ENOMEM);
760  goto err;
761  }
762  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
763  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
764  buf_size3 << 3);
765  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
766  slices[n_slices].rawbuf = divider;
767  slices[n_slices].raw_size = buf + buf_size - divider;
768  n_slices1 = n_slices - 1;
769  n_slices++;
770  }
771  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
772  } else {
773  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
774  }
775  init_get_bits(&s->gb, buf2, buf_size2*8);
776  } else
777  init_get_bits(&s->gb, buf, buf_size*8);
778 
779  if (v->res_sprite) {
780  v->new_sprite = !get_bits1(&s->gb);
781  v->two_sprites = get_bits1(&s->gb);
782  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
783  we're using the sprite compositor. These are intentionally kept separate
784  so you can get the raw sprites by using the wmv3 decoder for WMVP or
785  the vc1 one for WVP2 */
786  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
787  if (v->new_sprite) {
788  // switch AVCodecContext parameters to those of the sprites
789  avctx->width = avctx->coded_width = v->sprite_width;
790  avctx->height = avctx->coded_height = v->sprite_height;
791  } else {
792  goto image;
793  }
794  }
795  }
796 
797  if (s->context_initialized &&
798  (s->width != avctx->coded_width ||
799  s->height != avctx->coded_height)) {
800  ff_vc1_decode_end(avctx);
801  }
802 
803  if (!s->context_initialized) {
804  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
805  goto err;
806  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
808  goto err;
809  }
810 
811  s->low_delay = !avctx->has_b_frames || v->res_sprite;
812 
813  if (v->profile == PROFILE_ADVANCED) {
814  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
815  ret = AVERROR_INVALIDDATA;
816  goto err;
817  }
818  s->h_edge_pos = avctx->coded_width;
819  s->v_edge_pos = avctx->coded_height;
820  }
821  }
822 
823  // do parse frame header
824  v->pic_header_flag = 0;
825  v->first_pic_header_flag = 1;
826  if (v->profile < PROFILE_ADVANCED) {
827  if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
828  goto err;
829  }
830  } else {
831  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
832  goto err;
833  }
834  }
835  v->first_pic_header_flag = 0;
836 
837  if (avctx->debug & FF_DEBUG_PICT_INFO)
838  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
839 
840  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
841  && s->pict_type != AV_PICTURE_TYPE_I) {
842  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
843  ret = AVERROR_INVALIDDATA;
844  goto err;
845  }
846  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
847  && v->field_mode) {
848  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
849  ret = AVERROR_INVALIDDATA;
850  goto err;
851  }
852  if ((s->mb_height >> v->field_mode) == 0) {
853  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
854  ret = AVERROR_INVALIDDATA;
855  goto err;
856  }
857 
858  // for skipping the frame
859  s->current_picture.f->pict_type = s->pict_type;
860  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
861 
862  /* skip B-frames if we don't have reference frames */
863  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
864  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
865  goto end;
866  }
867  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
868  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
869  avctx->skip_frame >= AVDISCARD_ALL) {
870  goto end;
871  }
872 
873  if (s->next_p_frame_damaged) {
874  if (s->pict_type == AV_PICTURE_TYPE_B)
875  goto end;
876  else
877  s->next_p_frame_damaged = 0;
878  }
879 
880  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
881  goto err;
882  }
883 
887 
888  // process pulldown flags
889  s->current_picture_ptr->f->repeat_pict = 0;
890  // Pulldown flags are only valid when 'broadcast' has been set.
891  // So ticks_per_frame will be 2
892  if (v->rff) {
893  // repeat field
894  s->current_picture_ptr->f->repeat_pict = 1;
895  } else if (v->rptfrm) {
896  // repeat frames
897  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
898  }
899 
900  s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
901  s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
902 
903  if (avctx->hwaccel) {
904  s->mb_y = 0;
905  if (v->field_mode && buf_start_second_field) {
906  // decode first field
907  s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
908  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
909  goto err;
910 
911  if (n_slices1 == -1) {
912  // no slices, decode the field as-is
913  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
914  goto err;
915  } else {
916  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
917  goto err;
918 
919  for (i = 0 ; i < n_slices1 + 1; i++) {
920  s->gb = slices[i].gb;
921  s->mb_y = slices[i].mby_start;
922 
923  v->pic_header_flag = get_bits1(&s->gb);
924  if (v->pic_header_flag) {
925  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
926  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
927  ret = AVERROR_INVALIDDATA;
928  if (avctx->err_recognition & AV_EF_EXPLODE)
929  goto err;
930  continue;
931  }
932  }
933 
934  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
935  goto err;
936  }
937  }
938 
939  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
940  goto err;
941 
942  // decode second field
943  s->gb = slices[n_slices1 + 1].gb;
944  s->mb_y = slices[n_slices1 + 1].mby_start;
945  s->picture_structure = PICT_TOP_FIELD + v->tff;
946  v->second_field = 1;
947  v->pic_header_flag = 0;
948  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
949  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
950  ret = AVERROR_INVALIDDATA;
951  goto err;
952  }
954 
955  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
956  goto err;
957 
958  if (n_slices - n_slices1 == 2) {
959  // no slices, decode the field as-is
960  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
961  goto err;
962  } else {
963  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
964  goto err;
965 
966  for (i = n_slices1 + 2; i < n_slices; i++) {
967  s->gb = slices[i].gb;
968  s->mb_y = slices[i].mby_start;
969 
970  v->pic_header_flag = get_bits1(&s->gb);
971  if (v->pic_header_flag) {
972  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
973  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
974  ret = AVERROR_INVALIDDATA;
975  if (avctx->err_recognition & AV_EF_EXPLODE)
976  goto err;
977  continue;
978  }
979  }
980 
981  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
982  goto err;
983  }
984  }
985 
986  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
987  goto err;
988  } else {
989  s->picture_structure = PICT_FRAME;
990  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
991  goto err;
992 
993  if (n_slices == 0) {
994  // no slices, decode the frame as-is
995  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
996  goto err;
997  } else {
998  // decode the frame part as the first slice
999  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1000  goto err;
1001 
1002  // and process the slices as additional slices afterwards
1003  for (i = 0 ; i < n_slices; i++) {
1004  s->gb = slices[i].gb;
1005  s->mb_y = slices[i].mby_start;
1006 
1007  v->pic_header_flag = get_bits1(&s->gb);
1008  if (v->pic_header_flag) {
1009  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1010  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1011  ret = AVERROR_INVALIDDATA;
1012  if (avctx->err_recognition & AV_EF_EXPLODE)
1013  goto err;
1014  continue;
1015  }
1016  }
1017 
1018  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1019  goto err;
1020  }
1021  }
1022  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1023  goto err;
1024  }
1025  } else {
1026  int header_ret = 0;
1027 
1029 
1030  v->end_mb_x = s->mb_width;
1031  if (v->field_mode) {
1032  s->current_picture.f->linesize[0] <<= 1;
1033  s->current_picture.f->linesize[1] <<= 1;
1034  s->current_picture.f->linesize[2] <<= 1;
1035  s->linesize <<= 1;
1036  s->uvlinesize <<= 1;
1037  }
1038  mb_height = s->mb_height >> v->field_mode;
1039 
1040  av_assert0 (mb_height > 0);
1041 
1042  for (i = 0; i <= n_slices; i++) {
1043  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1044  if (v->field_mode <= 0) {
1045  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1046  "picture boundary (%d >= %d)\n", i,
1047  slices[i - 1].mby_start, mb_height);
1048  continue;
1049  }
1050  v->second_field = 1;
1051  av_assert0((s->mb_height & 1) == 0);
1052  v->blocks_off = s->b8_stride * (s->mb_height&~1);
1053  v->mb_off = s->mb_stride * s->mb_height >> 1;
1054  } else {
1055  v->second_field = 0;
1056  v->blocks_off = 0;
1057  v->mb_off = 0;
1058  }
1059  if (i) {
1060  v->pic_header_flag = 0;
1061  if (v->field_mode && i == n_slices1 + 2) {
1062  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1063  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1064  ret = AVERROR_INVALIDDATA;
1065  if (avctx->err_recognition & AV_EF_EXPLODE)
1066  goto err;
1067  continue;
1068  }
1069  } else if (get_bits1(&s->gb)) {
1070  v->pic_header_flag = 1;
1071  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1072  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1073  ret = AVERROR_INVALIDDATA;
1074  if (avctx->err_recognition & AV_EF_EXPLODE)
1075  goto err;
1076  continue;
1077  }
1078  }
1079  }
1080  if (header_ret < 0)
1081  continue;
1082  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1083  if (!v->field_mode || v->second_field)
1084  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1085  else {
1086  if (i >= n_slices) {
1087  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1088  continue;
1089  }
1090  s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1091  }
1092  if (s->end_mb_y <= s->start_mb_y) {
1093  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1094  continue;
1095  }
1096  if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1097  (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1098  !v->cbpcy_vlc) {
1099  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1100  continue;
1101  }
1103  if (i != n_slices) {
1104  s->gb = slices[i].gb;
1105  }
1106  }
1107  if (v->field_mode) {
1108  v->second_field = 0;
1109  s->current_picture.f->linesize[0] >>= 1;
1110  s->current_picture.f->linesize[1] >>= 1;
1111  s->current_picture.f->linesize[2] >>= 1;
1112  s->linesize >>= 1;
1113  s->uvlinesize >>= 1;
1115  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1116  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1117  }
1118  }
1119  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1120  get_bits_count(&s->gb), s->gb.size_in_bits);
1121 // if (get_bits_count(&s->gb) > buf_size * 8)
1122 // return -1;
1123  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1124  ret = AVERROR_INVALIDDATA;
1125  goto err;
1126  }
1127  if ( !v->field_mode
1128  && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1129  && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1130  ff_er_frame_end(&s->er);
1131  }
1132 
1134 
1135  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1136 image:
1137  avctx->width = avctx->coded_width = v->output_width;
1138  avctx->height = avctx->coded_height = v->output_height;
1139  if (avctx->skip_frame >= AVDISCARD_NONREF)
1140  goto end;
1141  if (!v->sprite_output_frame &&
1142  !(v->sprite_output_frame = av_frame_alloc())) {
1143  ret = AVERROR(ENOMEM);
1144  goto err;
1145  }
1146 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1147  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1148  goto err;
1149 #endif
1150  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1151  goto err;
1152  *got_frame = 1;
1153  } else {
1154  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1155  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1156  goto err;
1157  if (!v->field_mode)
1158  ff_print_debug_info(s, s->current_picture_ptr, pict);
1159  *got_frame = 1;
1160  } else if (s->last_picture_ptr) {
1161  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1162  goto err;
1163  if (!v->field_mode)
1164  ff_print_debug_info(s, s->last_picture_ptr, pict);
1165  *got_frame = 1;
1166  }
1167  }
1168 
1169 end:
1170  av_free(buf2);
1171  for (i = 0; i < n_slices; i++)
1172  av_free(slices[i].buf);
1173  av_free(slices);
1174  return buf_size;
1175 
1176 err:
1177  av_free(buf2);
1178  for (i = 0; i < n_slices; i++)
1179  av_free(slices[i].buf);
1180  av_free(slices);
1181  return ret;
1182 }
1183 
1184 
1185 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1186 #if CONFIG_VC1_DXVA2_HWACCEL
1188 #endif
1189 #if CONFIG_VC1_D3D11VA_HWACCEL
1192 #endif
1193 #if CONFIG_VC1_NVDEC_HWACCEL
1195 #endif
1196 #if CONFIG_VC1_VAAPI_HWACCEL
1198 #endif
1199 #if CONFIG_VC1_VDPAU_HWACCEL
1201 #endif
1204 };
1205 
1207  .name = "vc1",
1208  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1209  .type = AVMEDIA_TYPE_VIDEO,
1210  .id = AV_CODEC_ID_VC1,
1211  .priv_data_size = sizeof(VC1Context),
1212  .init = vc1_decode_init,
1213  .close = ff_vc1_decode_end,
1215  .flush = ff_mpeg_flush,
1216  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1218  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1219 #if CONFIG_VC1_DXVA2_HWACCEL
1220  HWACCEL_DXVA2(vc1),
1221 #endif
1222 #if CONFIG_VC1_D3D11VA_HWACCEL
1223  HWACCEL_D3D11VA(vc1),
1224 #endif
1225 #if CONFIG_VC1_D3D11VA2_HWACCEL
1226  HWACCEL_D3D11VA2(vc1),
1227 #endif
1228 #if CONFIG_VC1_NVDEC_HWACCEL
1229  HWACCEL_NVDEC(vc1),
1230 #endif
1231 #if CONFIG_VC1_VAAPI_HWACCEL
1232  HWACCEL_VAAPI(vc1),
1233 #endif
1234 #if CONFIG_VC1_VDPAU_HWACCEL
1235  HWACCEL_VDPAU(vc1),
1236 #endif
1237  NULL
1238  },
1240 };
1241 
1242 #if CONFIG_WMV3_DECODER
1244  .name = "wmv3",
1245  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1246  .type = AVMEDIA_TYPE_VIDEO,
1247  .id = AV_CODEC_ID_WMV3,
1248  .priv_data_size = sizeof(VC1Context),
1249  .init = vc1_decode_init,
1250  .close = ff_vc1_decode_end,
1252  .flush = ff_mpeg_flush,
1253  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1255  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1256 #if CONFIG_WMV3_DXVA2_HWACCEL
1257  HWACCEL_DXVA2(wmv3),
1258 #endif
1259 #if CONFIG_WMV3_D3D11VA_HWACCEL
1260  HWACCEL_D3D11VA(wmv3),
1261 #endif
1262 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1263  HWACCEL_D3D11VA2(wmv3),
1264 #endif
1265 #if CONFIG_WMV3_NVDEC_HWACCEL
1266  HWACCEL_NVDEC(wmv3),
1267 #endif
1268 #if CONFIG_WMV3_VAAPI_HWACCEL
1269  HWACCEL_VAAPI(wmv3),
1270 #endif
1271 #if CONFIG_WMV3_VDPAU_HWACCEL
1272  HWACCEL_VDPAU(wmv3),
1273 #endif
1274  NULL
1275  },
1277 };
1278 #endif
1279 
1280 #if CONFIG_WMV3IMAGE_DECODER
1282  .name = "wmv3image",
1283  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1284  .type = AVMEDIA_TYPE_VIDEO,
1285  .id = AV_CODEC_ID_WMV3IMAGE,
1286  .priv_data_size = sizeof(VC1Context),
1287  .init = vc1_decode_init,
1288  .close = ff_vc1_decode_end,
1290  .capabilities = AV_CODEC_CAP_DR1,
1291  .flush = vc1_sprite_flush,
1292  .pix_fmts = (const enum AVPixelFormat[]) {
1295  },
1296 };
1297 #endif
1298 
1299 #if CONFIG_VC1IMAGE_DECODER
1301  .name = "vc1image",
1302  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1303  .type = AVMEDIA_TYPE_VIDEO,
1304  .id = AV_CODEC_ID_VC1IMAGE,
1305  .priv_data_size = sizeof(VC1Context),
1306  .init = vc1_decode_init,
1307  .close = ff_vc1_decode_end,
1309  .capabilities = AV_CODEC_CAP_DR1,
1310  .flush = vc1_sprite_flush,
1311  .pix_fmts = (const enum AVPixelFormat[]) {
1314  },
1315 };
1316 #endif
static void flush(AVCodecContext *avctx)
AVCodec ff_vc1image_decoder
AVCodec ff_wmv3_decoder
AVCodec ff_wmv3image_decoder
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1624
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
#define AV_RB32
Definition: intreadwrite.h:130
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
#define f(width, name)
Definition: cbs_vp9.c:255
#define FFSWAP(type, a, b)
Definition: common.h:108
#define FFMIN(a, b)
Definition: common.h:105
#define av_clip
Definition: common.h:122
#define FFMAX(a, b)
Definition: common.h:103
#define av_clip_uint16
Definition: common.h:134
#define CONFIG_GRAY
Definition: config.h:556
#define NULL
Definition: coverity.c:32
#define abs(x)
Definition: cuda_runtime.h:35
#define IS_MARKER(state)
Definition: dca_parser.c:51
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1326
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
void ff_er_frame_end(ERContext *s)
bitstream reader API header.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#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:77
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:325
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:201
@ AV_CODEC_ID_VC1
Definition: codec_id.h:119
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:200
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:120
#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
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:235
@ AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:232
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:83
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_BI
BI type.
Definition: avutil.h:280
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:67
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:79
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
static const int16_t alpha[]
Definition: ilbcdata.h:55
int i
Definition: input.c:407
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:694
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:734
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
AVCodec ff_vc1_decoder
Definition: vc1dec.c:1206
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:588
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:422
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:324
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1185
#define transpose(x)
static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:623
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:403
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
#define FFALIGN(x, a)
Definition: macros.h:48
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define PICT_FRAME
Definition: mpegutils.h:39
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:1181
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1111
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1405
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2300
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1413
mpegvideo header.
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:294
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1807
MSMPEG4 data tables.
const char data[16]
Definition: mxf.c:142
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:569
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:552
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:137
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:235
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:313
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:229
@ AV_PIX_FMT_VAAPI
Definition: pixfmt.h:122
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:197
const AVProfile ff_vc1_profiles[]
Definition: profiles.c:131
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:783
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int debug
debug
Definition: avcodec.h:1623
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
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:796
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:826
int level
level
Definition: avcodec.h:1984
const struct AVCodec * codec
Definition: avcodec.h:545
int profile
profile
Definition: avcodec.h:1858
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
int coded_height
Definition: avcodec.h:724
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
enum AVCodecID codec_id
Definition: avcodec.h:546
int extradata_size
Definition: avcodec.h:638
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
void * priv_data
Definition: avcodec.h:563
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2006
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
AVCodec.
Definition: codec.h:197
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:218
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:470
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:465
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
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:2500
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2528
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2539
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
int size_in_bits
Definition: get_bits.h:68
MpegEncContext.
Definition: mpegvideo.h:81
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
struct AVFrame * f
Definition: mpegpicture.h:46
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:80
The VC1 Context.
Definition: vc1.h:173
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition: vc1.h:381
int16_t(* luma_mv_base)[2]
Definition: vc1.h:392
int transfer_char
8 bits, Opto-electronic transfer characteristics
Definition: vc1.h:205
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags.
Definition: vc1.h:216
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:238
int left_blk_sh
Definition: vc1.h:238
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:322
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:285
int pic_header_flag
Definition: vc1.h:368
int first_pic_header_flag
Definition: vc1.h:367
uint8_t * mb_type[3]
Definition: vc1.h:262
int output_width
Definition: vc1.h:380
int p_frame_skipped
Definition: vc1.h:384
int two_sprites
Definition: vc1.h:378
uint8_t tff
Definition: vc1.h:310
VC1DSPContext vc1dsp
Definition: vc1.h:177
uint8_t * is_intra
Definition: vc1.h:391
int new_sprite
Frame decoding info for sprite modes.
Definition: vc1.h:377
int bi_type
Definition: vc1.h:385
int second_field
Definition: vc1.h:353
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition: vc1.h:237
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:397
uint8_t * is_intra_base
Definition: vc1.h:391
H264ChromaContext h264chroma
Definition: vc1.h:176
uint8_t * mb_type_base
Definition: vc1.h:262
int * ttblk
Transform type at the block level.
Definition: vc1.h:257
int res_fasttx
reserved, always 1
Definition: vc1.h:185
int field_mode
1 for interlaced field pictures
Definition: vc1.h:351
uint32_t * cbp_base
Definition: vc1.h:390
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:181
int16_t(* block)[6][64]
Definition: vc1.h:388
uint16_t * hrd_buffer
Definition: vc1.h:325
int sprite_height
Definition: vc1.h:380
uint8_t * fieldtx_plane
Definition: vc1.h:345
uint8_t * mv_f_next_base
Definition: vc1.h:350
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:284
MpegEncContext s
Definition: vc1.h:174
int color_prim
8 bits, chroma coordinates of the color primaries
Definition: vc1.h:204
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:282
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:349
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:320
int n_allocated_blks
Definition: vc1.h:389
IntraX8Context x8
Definition: vc1.h:175
int sprite_width
Definition: vc1.h:380
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:348
int level
Advanced Profile.
Definition: vc1.h:195
uint8_t rff
Definition: vc1.h:310
uint32_t * cbp
Definition: vc1.h:390
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:307
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:199
int * ttblk_base
Definition: vc1.h:257
int blocks_off
Definition: vc1.h:363
int output_height
Definition: vc1.h:380
uint8_t * blk_mv_type_base
Definition: vc1.h:348
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:286
int16_t((* luma_mv)[2]
Definition: vc1.h:392
AVFrame * sprite_output_frame
Definition: vc1.h:379
uint8_t * mv_f_next[2]
Definition: vc1.h:350
int matrix_coef
8 bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:206
int mb_off
Definition: vc1.h:363
uint8_t rptfrm
Definition: vc1.h:310
uint8_t zzi_8x8[64]
Definition: vc1.h:347
uint8_t * mv_f_base
Definition: vc1.h:349
uint16_t * hrd_rate
Definition: vc1.h:325
void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)
Definition: vc1dsp.h:68
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
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
void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)
Definition: vc1dsp.h:69
void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)
Definition: vc1dsp.h:67
#define av_free(p)
#define ff_dlog(a,...)
#define avpriv_request_sample(...)
#define av_freep(p)
#define av_malloc(s)
#define av_log(a,...)
static void error(const char *err)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
#define width
int size
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1703
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:851
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:277
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:627
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:509
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2993
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition: vc1.h:149
static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
Definition: vc1_common.h:70
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
@ PROFILE_ADVANCED
Definition: vc1_common.h:52
@ VC1_CODE_SEQHDR
Definition: vc1_common.h:40
@ VC1_CODE_ENDOFSEQ
Definition: vc1_common.h:35
@ VC1_CODE_FIELD
Definition: vc1_common.h:37
@ VC1_CODE_FRAME
Definition: vc1_common.h:38
@ VC1_CODE_SLICE
Definition: vc1_common.h:36
@ VC1_CODE_ENTRYPOINT
Definition: vc1_common.h:39
const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]
Definition: vc1data.c:1047
VC-1 tables.
static double c[64]