FFmpeg: libavcodec/vc1dec.c Source File

FFmpeg
vc1dec.c
Go to the documentation of this file.
1 /*
2  * VC-1 and WMV3 decoder
3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
4  * Copyright (c) 2006-2007 Konstantin Shishkov
5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * VC-1 and WMV3 decoder
27  */
28 
29 #include "avcodec.h"
30 #include "blockdsp.h"
31 #include "get_bits.h"
32 #include "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 
295  av_frame_unref(v->sprite_output_frame);
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 
324  av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
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 
403  av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
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]);
412  v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[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  */
422  static av_cold int vc1_decode_init(AVCodecContext *avctx)
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  ff_vc1_init_common(v);
438 
439  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
440  int count = 0;
441 
442  // looks like WMV3 has a sequence header stored in the extradata
443  // advanced sequence header may be before the first frame
444  // the last byte of the extradata is a version number, 1 for the
445  // samples we can decode
446 
447  ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);
448  if (ret < 0)
449  return ret;
450 
451  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
452  return ret;
453 
454  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
455  avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
456  return AVERROR_PATCHWELCOME;
457  }
458 
459  count = avctx->extradata_size*8 - get_bits_count(&gb);
460  if (count > 0) {
461  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
462  count, get_bits_long(&gb, FFMIN(count, 32)));
463  } else if (count < 0) {
464  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
465  }
466  } else { // VC1/WVC1/WVP2
467  const uint8_t *start = avctx->extradata;
468  uint8_t *end = avctx->extradata + avctx->extradata_size;
469  const uint8_t *next;
470  int size, buf2_size;
471  uint8_t *buf2 = NULL;
472  int seq_initialized = 0, ep_initialized = 0;
473 
474  if (avctx->extradata_size < 16) {
475  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
476  return AVERROR_INVALIDDATA;
477  }
478 
479  buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
480  if (!buf2)
481  return AVERROR(ENOMEM);
482 
483  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
484  next = start;
485  for (; next < end; start = next) {
486  next = find_next_marker(start + 4, end);
487  size = next - start - 4;
488  if (size <= 0)
489  continue;
490  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
491  init_get_bits(&gb, buf2, buf2_size * 8);
492  switch (AV_RB32(start)) {
493  case VC1_CODE_SEQHDR:
494  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
495  av_free(buf2);
496  return ret;
497  }
498  seq_initialized = 1;
499  break;
500  case VC1_CODE_ENTRYPOINT:
501  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
502  av_free(buf2);
503  return ret;
504  }
505  ep_initialized = 1;
506  break;
507  }
508  }
509  av_free(buf2);
510  if (!seq_initialized || !ep_initialized) {
511  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
512  return AVERROR_INVALIDDATA;
513  }
514  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
515  }
516 
517  avctx->profile = v->profile;
518  if (v->profile == PROFILE_ADVANCED)
519  avctx->level = v->level;
520 
521  if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
522  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
523  else {
524  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
525  if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
526  avctx->color_range = AVCOL_RANGE_MPEG;
527  }
528 
529  // ensure static VLC tables are initialized
530  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
531  return ret;
532  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
533  return ret;
534  // Hack to ensure the above functions will be called
535  // again once we know all necessary settings.
536  // That this is necessary might indicate a bug.
537  ff_vc1_decode_end(avctx);
538 
539  ff_blockdsp_init(&s->bdsp, avctx);
540  ff_h264chroma_init(&v->h264chroma, 8);
541  ff_qpeldsp_init(&s->qdsp);
542 
543  avctx->has_b_frames = !!avctx->max_b_frames;
544 
545  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
546  avctx->color_primaries = v->color_prim;
547  if (v->transfer_char == 1 || v->transfer_char == 7)
548  avctx->color_trc = v->transfer_char;
549  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
550  avctx->colorspace = v->matrix_coef;
551 
552  s->mb_width = (avctx->coded_width + 15) >> 4;
553  s->mb_height = (avctx->coded_height + 15) >> 4;
554 
555  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
556  ff_vc1_init_transposed_scantables(v);
557  } else {
558  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
559  v->left_blk_sh = 3;
560  v->top_blk_sh = 0;
561  }
562 
563  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
564  v->sprite_width = avctx->coded_width;
565  v->sprite_height = avctx->coded_height;
566 
567  avctx->coded_width = avctx->width = v->output_width;
568  avctx->coded_height = avctx->height = v->output_height;
569 
570  // prevent 16.16 overflows
571  if (v->sprite_width > 1 << 14 ||
572  v->sprite_height > 1 << 14 ||
573  v->output_width > 1 << 14 ||
574  v->output_height > 1 << 14) {
575  return AVERROR_INVALIDDATA;
576  }
577 
578  if ((v->sprite_width&1) || (v->sprite_height&1)) {
579  avpriv_request_sample(avctx, "odd sprites support");
580  return AVERROR_PATCHWELCOME;
581  }
582  }
583  return 0;
584 }
585 
586 /** Close a VC1/WMV3 decoder
587  * @warning Initial try at using MpegEncContext stuff
588  */
589  av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
590 {
591  VC1Context *v = avctx->priv_data;
592  int i;
593 
594  av_frame_free(&v->sprite_output_frame);
595 
596  for (i = 0; i < 4; i++)
597  av_freep(&v->sr_rows[i >> 1][i & 1]);
598  ff_mpv_common_end(&v->s);
599  av_freep(&v->mv_type_mb_plane);
600  av_freep(&v->direct_mb_plane);
601  av_freep(&v->forward_mb_plane);
602  av_freep(&v->fieldtx_plane);
603  av_freep(&v->acpred_plane);
604  av_freep(&v->over_flags_plane);
605  av_freep(&v->mb_type_base);
606  av_freep(&v->blk_mv_type_base);
607  av_freep(&v->mv_f_base);
608  av_freep(&v->mv_f_next_base);
609  av_freep(&v->block);
610  av_freep(&v->cbp_base);
611  av_freep(&v->ttblk_base);
612  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
613  av_freep(&v->luma_mv_base);
614  ff_intrax8_common_end(&v->x8);
615  return 0;
616 }
617 
618 
619 /** Decode a VC1/WMV3 frame
620  * @todo TODO: Handle VC-1 IDUs (Transport level?)
621  */
622  static int vc1_decode_frame(AVCodecContext *avctx, void *data,
623  int *got_frame, AVPacket *avpkt)
624 {
625  const uint8_t *buf = avpkt->data;
626  int buf_size = avpkt->size, n_slices = 0, i, ret;
627  VC1Context *v = avctx->priv_data;
628  MpegEncContext *s = &v->s;
629  AVFrame *pict = data;
630  uint8_t *buf2 = NULL;
631  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
632  int mb_height, n_slices1=-1;
633  struct {
634  uint8_t *buf;
635  GetBitContext gb;
636  int mby_start;
637  const uint8_t *rawbuf;
638  int raw_size;
639  } *slices = NULL, *tmp;
640 
641  v->second_field = 0;
642 
643  if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
644  s->low_delay = 1;
645 
646  /* no supplementary picture */
647  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
648  /* special case for last picture */
649  if (s->low_delay == 0 && s->next_picture_ptr) {
650  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
651  return ret;
652  s->next_picture_ptr = NULL;
653 
654  *got_frame = 1;
655  }
656 
657  return buf_size;
658  }
659 
660  //for advanced profile we may need to parse and unescape data
661  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
662  int buf_size2 = 0;
663  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
664  if (!buf2)
665  return AVERROR(ENOMEM);
666 
667  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
668  const uint8_t *start, *end, *next;
669  int size;
670 
671  next = buf;
672  for (start = buf, end = buf + buf_size; next < end; start = next) {
673  next = find_next_marker(start + 4, end);
674  size = next - start - 4;
675  if (size <= 0) continue;
676  switch (AV_RB32(start)) {
677  case VC1_CODE_FRAME:
678  if (avctx->hwaccel)
679  buf_start = start;
680  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
681  break;
682  case VC1_CODE_FIELD: {
683  int buf_size3;
684  if (avctx->hwaccel)
685  buf_start_second_field = start;
686  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
687  if (!tmp) {
688  ret = AVERROR(ENOMEM);
689  goto err;
690  }
691  slices = tmp;
692  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
693  if (!slices[n_slices].buf) {
694  ret = AVERROR(ENOMEM);
695  goto err;
696  }
697  buf_size3 = vc1_unescape_buffer(start + 4, size,
698  slices[n_slices].buf);
699  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
700  buf_size3 << 3);
701  slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
702  slices[n_slices].rawbuf = start;
703  slices[n_slices].raw_size = size + 4;
704  n_slices1 = n_slices - 1; // index of the last slice of the first field
705  n_slices++;
706  break;
707  }
708  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
709  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
710  init_get_bits(&s->gb, buf2, buf_size2 * 8);
711  ff_vc1_decode_entry_point(avctx, v, &s->gb);
712  break;
713  case VC1_CODE_SLICE: {
714  int buf_size3;
715  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
716  if (!tmp) {
717  ret = AVERROR(ENOMEM);
718  goto err;
719  }
720  slices = tmp;
721  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
722  if (!slices[n_slices].buf) {
723  ret = AVERROR(ENOMEM);
724  goto err;
725  }
726  buf_size3 = vc1_unescape_buffer(start + 4, size,
727  slices[n_slices].buf);
728  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
729  buf_size3 << 3);
730  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
731  slices[n_slices].rawbuf = start;
732  slices[n_slices].raw_size = size + 4;
733  n_slices++;
734  break;
735  }
736  }
737  }
738  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
739  const uint8_t *divider;
740  int buf_size3;
741 
742  divider = find_next_marker(buf, buf + buf_size);
743  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
744  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
745  ret = AVERROR_INVALIDDATA;
746  goto err;
747  } else { // found field marker, unescape second field
748  if (avctx->hwaccel)
749  buf_start_second_field = divider;
750  tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
751  if (!tmp) {
752  ret = AVERROR(ENOMEM);
753  goto err;
754  }
755  slices = tmp;
756  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
757  if (!slices[n_slices].buf) {
758  ret = AVERROR(ENOMEM);
759  goto err;
760  }
761  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
762  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
763  buf_size3 << 3);
764  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
765  slices[n_slices].rawbuf = divider;
766  slices[n_slices].raw_size = buf + buf_size - divider;
767  n_slices1 = n_slices - 1;
768  n_slices++;
769  }
770  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
771  } else {
772  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
773  }
774  init_get_bits(&s->gb, buf2, buf_size2*8);
775  } else{
776  ret = init_get_bits8(&s->gb, buf, buf_size);
777  if (ret < 0)
778  return ret;
779  }
780 
781  if (v->res_sprite) {
782  v->new_sprite = !get_bits1(&s->gb);
783  v->two_sprites = get_bits1(&s->gb);
784  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
785  we're using the sprite compositor. These are intentionally kept separate
786  so you can get the raw sprites by using the wmv3 decoder for WMVP or
787  the vc1 one for WVP2 */
788  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
789  if (v->new_sprite) {
790  // switch AVCodecContext parameters to those of the sprites
791  avctx->width = avctx->coded_width = v->sprite_width;
792  avctx->height = avctx->coded_height = v->sprite_height;
793  } else {
794  goto image;
795  }
796  }
797  }
798 
799  if (s->context_initialized &&
800  (s->width != avctx->coded_width ||
801  s->height != avctx->coded_height)) {
802  ff_vc1_decode_end(avctx);
803  }
804 
805  if (!s->context_initialized) {
806  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
807  goto err;
808  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
809  ff_mpv_common_end(s);
810  goto err;
811  }
812 
813  s->low_delay = !avctx->has_b_frames || v->res_sprite;
814 
815  if (v->profile == PROFILE_ADVANCED) {
816  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
817  ret = AVERROR_INVALIDDATA;
818  goto err;
819  }
820  s->h_edge_pos = avctx->coded_width;
821  s->v_edge_pos = avctx->coded_height;
822  }
823  }
824 
825  // do parse frame header
826  v->pic_header_flag = 0;
827  v->first_pic_header_flag = 1;
828  if (v->profile < PROFILE_ADVANCED) {
829  if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
830  goto err;
831  }
832  } else {
833  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
834  goto err;
835  }
836  }
837  v->first_pic_header_flag = 0;
838 
839  if (avctx->debug & FF_DEBUG_PICT_INFO)
840  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
841 
842  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
843  && s->pict_type != AV_PICTURE_TYPE_I) {
844  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
845  ret = AVERROR_INVALIDDATA;
846  goto err;
847  }
848  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
849  && v->field_mode) {
850  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
851  ret = AVERROR_INVALIDDATA;
852  goto err;
853  }
854  if ((s->mb_height >> v->field_mode) == 0) {
855  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
856  ret = AVERROR_INVALIDDATA;
857  goto err;
858  }
859 
860  // for skipping the frame
861  s->current_picture.f->pict_type = s->pict_type;
862  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
863 
864  /* skip B-frames if we don't have reference frames */
865  if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
866  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
867  goto end;
868  }
869  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
870  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
871  avctx->skip_frame >= AVDISCARD_ALL) {
872  goto end;
873  }
874 
875  if (s->next_p_frame_damaged) {
876  if (s->pict_type == AV_PICTURE_TYPE_B)
877  goto end;
878  else
879  s->next_p_frame_damaged = 0;
880  }
881 
882  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
883  goto err;
884  }
885 
886  v->s.current_picture_ptr->field_picture = v->field_mode;
887  v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
888  v->s.current_picture_ptr->f->top_field_first = v->tff;
889 
890  // process pulldown flags
891  s->current_picture_ptr->f->repeat_pict = 0;
892  // Pulldown flags are only valid when 'broadcast' has been set.
893  // So ticks_per_frame will be 2
894  if (v->rff) {
895  // repeat field
896  s->current_picture_ptr->f->repeat_pict = 1;
897  } else if (v->rptfrm) {
898  // repeat frames
899  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
900  }
901 
902  s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
903  s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
904 
905  if (avctx->hwaccel) {
906  s->mb_y = 0;
907  if (v->field_mode && buf_start_second_field) {
908  // decode first field
909  s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
910  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
911  goto err;
912 
913  if (n_slices1 == -1) {
914  // no slices, decode the field as-is
915  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
916  goto err;
917  } else {
918  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
919  goto err;
920 
921  for (i = 0 ; i < n_slices1 + 1; i++) {
922  s->gb = slices[i].gb;
923  s->mb_y = slices[i].mby_start;
924 
925  v->pic_header_flag = get_bits1(&s->gb);
926  if (v->pic_header_flag) {
927  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
928  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
929  ret = AVERROR_INVALIDDATA;
930  if (avctx->err_recognition & AV_EF_EXPLODE)
931  goto err;
932  continue;
933  }
934  }
935 
936  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
937  goto err;
938  }
939  }
940 
941  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
942  goto err;
943 
944  // decode second field
945  s->gb = slices[n_slices1 + 1].gb;
946  s->mb_y = slices[n_slices1 + 1].mby_start;
947  s->picture_structure = PICT_TOP_FIELD + v->tff;
948  v->second_field = 1;
949  v->pic_header_flag = 0;
950  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
951  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
952  ret = AVERROR_INVALIDDATA;
953  goto err;
954  }
955  v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
956 
957  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
958  goto err;
959 
960  if (n_slices - n_slices1 == 2) {
961  // no slices, decode the field as-is
962  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
963  goto err;
964  } else {
965  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
966  goto err;
967 
968  for (i = n_slices1 + 2; i < n_slices; i++) {
969  s->gb = slices[i].gb;
970  s->mb_y = slices[i].mby_start;
971 
972  v->pic_header_flag = get_bits1(&s->gb);
973  if (v->pic_header_flag) {
974  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
975  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
976  ret = AVERROR_INVALIDDATA;
977  if (avctx->err_recognition & AV_EF_EXPLODE)
978  goto err;
979  continue;
980  }
981  }
982 
983  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
984  goto err;
985  }
986  }
987 
988  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
989  goto err;
990  } else {
991  s->picture_structure = PICT_FRAME;
992  if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
993  goto err;
994 
995  if (n_slices == 0) {
996  // no slices, decode the frame as-is
997  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
998  goto err;
999  } else {
1000  // decode the frame part as the first slice
1001  if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1002  goto err;
1003 
1004  // and process the slices as additional slices afterwards
1005  for (i = 0 ; i < n_slices; i++) {
1006  s->gb = slices[i].gb;
1007  s->mb_y = slices[i].mby_start;
1008 
1009  v->pic_header_flag = get_bits1(&s->gb);
1010  if (v->pic_header_flag) {
1011  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1012  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1013  ret = AVERROR_INVALIDDATA;
1014  if (avctx->err_recognition & AV_EF_EXPLODE)
1015  goto err;
1016  continue;
1017  }
1018  }
1019 
1020  if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1021  goto err;
1022  }
1023  }
1024  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1025  goto err;
1026  }
1027  } else {
1028  int header_ret = 0;
1029 
1030  ff_mpeg_er_frame_start(s);
1031 
1032  v->end_mb_x = s->mb_width;
1033  if (v->field_mode) {
1034  s->current_picture.f->linesize[0] <<= 1;
1035  s->current_picture.f->linesize[1] <<= 1;
1036  s->current_picture.f->linesize[2] <<= 1;
1037  s->linesize <<= 1;
1038  s->uvlinesize <<= 1;
1039  }
1040  mb_height = s->mb_height >> v->field_mode;
1041 
1042  av_assert0 (mb_height > 0);
1043 
1044  for (i = 0; i <= n_slices; i++) {
1045  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1046  if (v->field_mode <= 0) {
1047  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1048  "picture boundary (%d >= %d)\n", i,
1049  slices[i - 1].mby_start, mb_height);
1050  continue;
1051  }
1052  v->second_field = 1;
1053  av_assert0((s->mb_height & 1) == 0);
1054  v->blocks_off = s->b8_stride * (s->mb_height&~1);
1055  v->mb_off = s->mb_stride * s->mb_height >> 1;
1056  } else {
1057  v->second_field = 0;
1058  v->blocks_off = 0;
1059  v->mb_off = 0;
1060  }
1061  if (i) {
1062  v->pic_header_flag = 0;
1063  if (v->field_mode && i == n_slices1 + 2) {
1064  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1065  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1066  ret = AVERROR_INVALIDDATA;
1067  if (avctx->err_recognition & AV_EF_EXPLODE)
1068  goto err;
1069  continue;
1070  }
1071  } else if (get_bits1(&s->gb)) {
1072  v->pic_header_flag = 1;
1073  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1074  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1075  ret = AVERROR_INVALIDDATA;
1076  if (avctx->err_recognition & AV_EF_EXPLODE)
1077  goto err;
1078  continue;
1079  }
1080  }
1081  }
1082  if (header_ret < 0)
1083  continue;
1084  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1085  if (!v->field_mode || v->second_field)
1086  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1087  else {
1088  if (i >= n_slices) {
1089  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1090  continue;
1091  }
1092  s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1093  }
1094  if (s->end_mb_y <= s->start_mb_y) {
1095  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1096  continue;
1097  }
1098  if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1099  (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1100  !v->cbpcy_vlc) {
1101  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1102  continue;
1103  }
1104  ff_vc1_decode_blocks(v);
1105  if (i != n_slices) {
1106  s->gb = slices[i].gb;
1107  }
1108  }
1109  if (v->field_mode) {
1110  v->second_field = 0;
1111  s->current_picture.f->linesize[0] >>= 1;
1112  s->current_picture.f->linesize[1] >>= 1;
1113  s->current_picture.f->linesize[2] >>= 1;
1114  s->linesize >>= 1;
1115  s->uvlinesize >>= 1;
1116  if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1117  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1118  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1119  }
1120  }
1121  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1122  get_bits_count(&s->gb), s->gb.size_in_bits);
1123 // if (get_bits_count(&s->gb) > buf_size * 8)
1124 // return -1;
1125  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1126  ret = AVERROR_INVALIDDATA;
1127  goto err;
1128  }
1129  if ( !v->field_mode
1130  && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1131  && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1132  ff_er_frame_end(&s->er);
1133  }
1134 
1135  ff_mpv_frame_end(s);
1136 
1137  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1138 image:
1139  avctx->width = avctx->coded_width = v->output_width;
1140  avctx->height = avctx->coded_height = v->output_height;
1141  if (avctx->skip_frame >= AVDISCARD_NONREF)
1142  goto end;
1143  if (!v->sprite_output_frame &&
1144  !(v->sprite_output_frame = av_frame_alloc())) {
1145  ret = AVERROR(ENOMEM);
1146  goto err;
1147  }
1148 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1149  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1150  goto err;
1151 #endif
1152  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1153  goto err;
1154  *got_frame = 1;
1155  } else {
1156  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1157  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1158  goto err;
1159  if (!v->field_mode)
1160  ff_print_debug_info(s, s->current_picture_ptr, pict);
1161  *got_frame = 1;
1162  } else if (s->last_picture_ptr) {
1163  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1164  goto err;
1165  if (!v->field_mode)
1166  ff_print_debug_info(s, s->last_picture_ptr, pict);
1167  *got_frame = 1;
1168  }
1169  }
1170 
1171 end:
1172  av_free(buf2);
1173  for (i = 0; i < n_slices; i++)
1174  av_free(slices[i].buf);
1175  av_free(slices);
1176  return buf_size;
1177 
1178 err:
1179  av_free(buf2);
1180  for (i = 0; i < n_slices; i++)
1181  av_free(slices[i].buf);
1182  av_free(slices);
1183  return ret;
1184 }
1185 
1186 
1187  static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1188 #if CONFIG_VC1_DXVA2_HWACCEL
1189  AV_PIX_FMT_DXVA2_VLD,
1190 #endif
1191 #if CONFIG_VC1_D3D11VA_HWACCEL
1192  AV_PIX_FMT_D3D11VA_VLD,
1193  AV_PIX_FMT_D3D11,
1194 #endif
1195 #if CONFIG_VC1_NVDEC_HWACCEL
1196  AV_PIX_FMT_CUDA,
1197 #endif
1198 #if CONFIG_VC1_VAAPI_HWACCEL
1199  AV_PIX_FMT_VAAPI,
1200 #endif
1201 #if CONFIG_VC1_VDPAU_HWACCEL
1202  AV_PIX_FMT_VDPAU,
1203 #endif
1204  AV_PIX_FMT_YUV420P,
1205  AV_PIX_FMT_NONE
1206 };
1207 
1208  const AVCodec ff_vc1_decoder = {
1209  .name = "vc1",
1210  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1211  .type = AVMEDIA_TYPE_VIDEO,
1212  .id = AV_CODEC_ID_VC1,
1213  .priv_data_size = sizeof(VC1Context),
1214  .init = vc1_decode_init,
1215  .close = ff_vc1_decode_end,
1216  .decode = vc1_decode_frame,
1217  .flush = ff_mpeg_flush,
1218  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1219  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1220  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1221 #if CONFIG_VC1_DXVA2_HWACCEL
1222  HWACCEL_DXVA2(vc1),
1223 #endif
1224 #if CONFIG_VC1_D3D11VA_HWACCEL
1225  HWACCEL_D3D11VA(vc1),
1226 #endif
1227 #if CONFIG_VC1_D3D11VA2_HWACCEL
1228  HWACCEL_D3D11VA2(vc1),
1229 #endif
1230 #if CONFIG_VC1_NVDEC_HWACCEL
1231  HWACCEL_NVDEC(vc1),
1232 #endif
1233 #if CONFIG_VC1_VAAPI_HWACCEL
1234  HWACCEL_VAAPI(vc1),
1235 #endif
1236 #if CONFIG_VC1_VDPAU_HWACCEL
1237  HWACCEL_VDPAU(vc1),
1238 #endif
1239  NULL
1240  },
1241  .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1242 };
1243 
1244 #if CONFIG_WMV3_DECODER
1245 const AVCodec ff_wmv3_decoder = {
1246  .name = "wmv3",
1247  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1248  .type = AVMEDIA_TYPE_VIDEO,
1249  .id = AV_CODEC_ID_WMV3,
1250  .priv_data_size = sizeof(VC1Context),
1251  .init = vc1_decode_init,
1252  .close = ff_vc1_decode_end,
1253  .decode = vc1_decode_frame,
1254  .flush = ff_mpeg_flush,
1255  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1256  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1257  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1258 #if CONFIG_WMV3_DXVA2_HWACCEL
1259  HWACCEL_DXVA2(wmv3),
1260 #endif
1261 #if CONFIG_WMV3_D3D11VA_HWACCEL
1262  HWACCEL_D3D11VA(wmv3),
1263 #endif
1264 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1265  HWACCEL_D3D11VA2(wmv3),
1266 #endif
1267 #if CONFIG_WMV3_NVDEC_HWACCEL
1268  HWACCEL_NVDEC(wmv3),
1269 #endif
1270 #if CONFIG_WMV3_VAAPI_HWACCEL
1271  HWACCEL_VAAPI(wmv3),
1272 #endif
1273 #if CONFIG_WMV3_VDPAU_HWACCEL
1274  HWACCEL_VDPAU(wmv3),
1275 #endif
1276  NULL
1277  },
1278  .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1279 };
1280 #endif
1281 
1282 #if CONFIG_WMV3IMAGE_DECODER
1283 const AVCodec ff_wmv3image_decoder = {
1284  .name = "wmv3image",
1285  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1286  .type = AVMEDIA_TYPE_VIDEO,
1287  .id = AV_CODEC_ID_WMV3IMAGE,
1288  .priv_data_size = sizeof(VC1Context),
1289  .init = vc1_decode_init,
1290  .close = ff_vc1_decode_end,
1291  .decode = vc1_decode_frame,
1292  .capabilities = AV_CODEC_CAP_DR1,
1293  .flush = vc1_sprite_flush,
1294  .pix_fmts = (const enum AVPixelFormat[]) {
1295  AV_PIX_FMT_YUV420P,
1296  AV_PIX_FMT_NONE
1297  },
1298 };
1299 #endif
1300 
1301 #if CONFIG_VC1IMAGE_DECODER
1302 const AVCodec ff_vc1image_decoder = {
1303  .name = "vc1image",
1304  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1305  .type = AVMEDIA_TYPE_VIDEO,
1306  .id = AV_CODEC_ID_VC1IMAGE,
1307  .priv_data_size = sizeof(VC1Context),
1308  .init = vc1_decode_init,
1309  .close = ff_vc1_decode_end,
1310  .decode = vc1_decode_frame,
1311  .capabilities = AV_CODEC_CAP_DR1,
1312  .flush = vc1_sprite_flush,
1313  .pix_fmts = (const enum AVPixelFormat[]) {
1314  AV_PIX_FMT_YUV420P,
1315  AV_PIX_FMT_NONE
1316  },
1317 };
1318 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
VC1DSPContext::sprite_v_double_noscale
void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)
Definition: vc1dsp.h:69
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
AVCodec
AVCodec.
Definition: codec.h:202
VC1Context::zz_8x8
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition: vc1.h:237
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
VC1Context::new_sprite
int new_sprite
Frame decoding info for sprite modes.
Definition: vc1.h:375
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:225
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_clip
#define av_clip
Definition: common.h:96
ff_msmpeg4_decode_init
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:294
VC1Context::two_sprites
int two_sprites
Definition: vc1.h:376
blockdsp.h
VC1Context
The VC1 Context.
Definition: vc1.h:173
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
PROGRESSIVE
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition: vc1.h:149
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
vc1_decode_frame
static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:622
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1089
vc1_hwaccel_pixfmt_list_420
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1187
VC1Context::cbp
uint32_t * cbp
Definition: vc1.h:388
VC1Context::end_mb_x
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:395
VC1Context::interlace
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:199
vc1.h
ff_wmv3image_decoder
const AVCodec ff_wmv3image_decoder
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1324
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
ff_wmv1_scantable
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1806
ff_qpeldsp_init
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:783
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:224
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:69
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
Picture::field_picture
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:80
VC1Context::sprite_height
int sprite_height
Definition: vc1.h:378
VC1Context::left_blk_sh
int left_blk_sh
Definition: vc1.h:238
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:953
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:67
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:474
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
data
const char data[16]
Definition: mxf.c:143
VC1Context::cbp_base
uint32_t * cbp_base
Definition: vc1.h:388
VC1Context::mv_type_mb_plane
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:284
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:219
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
mpegvideo.h
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:88
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
VC1Context::output_height
int output_height
Definition: vc1.h:378
VC1Context::luma_mv
int16_t((* luma_mv)[2]
Definition: vc1.h:390
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1303
VC1Context::rptfrm
uint8_t rptfrm
Definition: vc1.h:310
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
find_next_marker
static const av_always_inline uint8_t * find_next_marker(const uint8_t *src, const uint8_t *end)
Find VC-1 marker in buffer.
Definition: vc1_common.h:59
ff_vc1_parse_frame_header
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:627
init
static int init
Definition: av_tx.c:47
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:201
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1673
GetBitContext
Definition: get_bits.h:62
vc1_decode_init
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:422
VC1Context::first_pic_header_flag
int first_pic_header_flag
Definition: vc1.h:365
ff_vc1_decode_sequence_header
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:277
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
ff_wmv3_decoder
const AVCodec ff_wmv3_decoder
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:264
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
VC1Context::n_allocated_blks
int n_allocated_blks
Definition: vc1.h:387
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:97
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1128
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:946
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_intrax8_common_init
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
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
VC1DSPContext::sprite_v_double_twoscale
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
msmpeg4data.h
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:679
VC1_CODE_SLICE
@ VC1_CODE_SLICE
Definition: vc1_common.h:36
width
#define width
VC1Context::mb_type
uint8_t * mb_type[3]
Definition: vc1.h:262
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:127
s
#define s(width, name)
Definition: cbs_vp9.c:257
VC1Context::res_sprite
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:181
VC1Context::res_fasttx
int res_fasttx
reserved, always 1
Definition: vc1.h:185
VC1Context::mv_f
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:347
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:224
VC1DSPContext::sprite_h
void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)
Definition: vc1dsp.h:67
VC1Context::mb_type_base
uint8_t * mb_type_base
Definition: vc1.h:262
VC1Context::x8
IntraX8Context x8
Definition: vc1.h:175
VC1Context::over_flags_plane
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:322
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
PROFILE_ADVANCED
@ PROFILE_ADVANCED
Definition: vc1_common.h:52
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
get_bits.h
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_CODEC_ID_VC1IMAGE
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:202
f
#define f(width, name)
Definition: cbs_vp9.c:255
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
VC1Context::top_blk_sh
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:238
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AV_CODEC_ID_WMV3
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:121
ff_vc1_init_common
av_cold void ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1703
VC1Context::forward_mb_plane
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:286
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
VC1Context::direct_mb_plane
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:285
ff_vc1_init_transposed_scantables
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:403
VC1Context::field_mode
int field_mode
1 for interlaced field pictures
Definition: vc1.h:349
ff_vc1_decode_blocks
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2993
VC1Context::blk_mv_type_base
uint8_t * blk_mv_type_base
Definition: vc1.h:346
ff_intrax8_common_end
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:734
vc1_unescape_buffer
static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
Definition: vc1_common.h:70
VC1_CODE_SEQHDR
@ VC1_CODE_SEQHDR
Definition: vc1_common.h:40
VC1Context::block
int16_t(* block)[6][64]
Definition: vc1.h:386
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2140
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
profiles.h
IS_MARKER
#define IS_MARKER(state)
Definition: dca_parser.c:51
VC1_CODE_FIELD
@ VC1_CODE_FIELD
Definition: vc1_common.h:37
VC1_CODE_ENTRYPOINT
@ VC1_CODE_ENTRYPOINT
Definition: vc1_common.h:39
VC1Context::vc1dsp
VC1DSPContext vc1dsp
Definition: vc1.h:177
abs
#define abs(x)
Definition: cuda_runtime.h:35
VC1Context::luma_mv_base
int16_t(* luma_mv_base)[2]
Definition: vc1.h:390
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1335
VC1_CODE_FRAME
@ VC1_CODE_FRAME
Definition: vc1_common.h:38
AVCodecContext::level
int level
level
Definition: avcodec.h:1651
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:563
VC1Context::h264chroma
H264ChromaContext h264chroma
Definition: vc1.h:176
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
VC1Context::fieldtx_plane
uint8_t * fieldtx_plane
Definition: vc1.h:343
ff_vc1_adv_interlaced_8x8_zz
const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]
Definition: vc1data.c:1047
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:53
VC1Context::mv_f_next
uint8_t * mv_f_next[2]
Definition: vc1.h:348
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:414
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
VC1Context::is_intra
uint8_t * is_intra
Definition: vc1.h:389
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:243
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
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:325
VC1Context::ttblk_base
int * ttblk_base
Definition: vc1.h:257
VC1Context::mb_off
int mb_off
Definition: vc1.h:361
ff_vc1_decoder
const AVCodec ff_vc1_decoder
Definition: vc1dec.c:1208
size
int size
Definition: twinvq_data.h:10344
VC1Context::zzi_8x8
uint8_t zzi_8x8[64]
Definition: vc1.h:345
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
VC1Context::sprite_width
int sprite_width
Definition: vc1.h:378
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2319
AVCodecHWConfigInternal
Definition: hwconfig.h:29
vc1data.h
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:79
VC1DSPContext::sprite_v_single
void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)
Definition: vc1dsp.h:68
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:303
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1432
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:119
VC1Context::sr_rows
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition: vc1.h:379
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:187
av_get_picture_type_char
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
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:469
MpegEncContext::current_picture_ptr
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:174
VC1DSPContext::sprite_v_double_onescale
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
ff_vc1_decode_init_alloc_tables
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:324
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2129
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
ff_vc1_decode_entry_point
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:509
ff_vc1_parse_frame_header_adv
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:851
VC1Context::s
MpegEncContext s
Definition: vc1.h:174
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:435
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
VC1Context::pic_header_flag
int pic_header_flag
Definition: vc1.h:366
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
VC1Context::ttblk
int * ttblk
Transform type at the block level.
Definition: vc1.h:257
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:120
AVCodecContext::height
int height
Definition: avcodec.h:556
VC1Context::is_intra_base
uint8_t * is_intra_base
Definition: vc1.h:389
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1424
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:580
avcodec.h
msmpeg4.h
VC1Context::second_field
int second_field
Definition: vc1.h:351
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
VC1Context::sprite_output_frame
AVFrame * sprite_output_frame
Definition: vc1.h:377
VC1Context::output_width
int output_width
Definition: vc1.h:378
VC1Context::color_prim
int color_prim
8 bits, chroma coordinates of the color primaries
Definition: vc1.h:204
ff_mpv_frame_start
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:1200
VC1Context::mv_f_next_base
uint8_t * mv_f_next_base
Definition: vc1.h:348
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:383
VC1Context::p_frame_skipped
int p_frame_skipped
Definition: vc1.h:382
VC1Context::cbpcy_vlc
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:282
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:46
VC1Context::tff
uint8_t tff
Definition: vc1.h:310
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
ff_vc1image_decoder
const AVCodec ff_vc1image_decoder
VC1Context::profile
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags.
Definition: vc1.h:216
AV_CODEC_CAP_DELAY
#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:82
ff_vc1_profiles
const AVProfile ff_vc1_profiles[]
Definition: profiles.c:131
VC1Context::matrix_coef
int matrix_coef
8 bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:206
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1302
av_clip_uint16
#define av_clip_uint16
Definition: common.h:108
VC1Context::bi_type
int bi_type
Definition: vc1.h:383
AVHWAccel::start_frame
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:2101
VC1Context::mv_f_base
uint8_t * mv_f_base
Definition: vc1.h:347
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:571
VC1Context::fcm
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:307
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::max_b_frames
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:655
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
VC1Context::level
int level
Advanced Profile.
Definition: vc1.h:195
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
VC1Context::acpred_plane
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:320
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:896
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PICTURE_TYPE_BI
@ AV_PICTURE_TYPE_BI
BI type.
Definition: avutil.h:280
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
mpeg_er.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:362
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
VC1Context::transfer_char
int transfer_char
8 bits, Opto-electronic transfer characteristics
Definition: vc1.h:205
ff_vc1_decode_end
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:589
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
VC1Context::blk_mv_type
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:346
AV_CODEC_ID_WMV3IMAGE
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:201
transpose
#define transpose(x)
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:59
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:50
VC1Context::blocks_off
int blocks_off
Definition: vc1.h:361
VC1_CODE_ENDOFSEQ
@ VC1_CODE_ENDOFSEQ
Definition: vc1_common.h:35
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:71
VC1Context::rff
uint8_t rff
Definition: vc1.h:310
Generated on Wed Aug 24 2022 21:37:58 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /