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 "config_components.h"
30 
31 #include "avcodec.h"
32 #include "blockdsp.h"
33 #include "codec_internal.h"
34 #include "decode.h"
35 #include "get_bits.h"
36 #include "hwaccel_internal.h"
37 #include "hwconfig.h"
38 #include "mpeg_er.h"
39 #include "mpegutils.h"
40 #include "mpegvideo.h"
41 #include "mpegvideodec.h"
42 #include "msmpeg4_vc1_data.h"
43 #include "profiles.h"
44 #include "simple_idct.h"
45 #include "vc1.h"
46 #include "vc1data.h"
47 #include "vc1_vlc_data.h"
48 #include "libavutil/attributes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/imgutils.h"
51 #include "libavutil/mem.h"
52 #include "libavutil/thread.h"
53 
54 
55 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
56 #if CONFIG_VC1_DXVA2_HWACCEL
57  AV_PIX_FMT_DXVA2_VLD,
58 #endif
59 #if CONFIG_VC1_D3D11VA_HWACCEL
60  AV_PIX_FMT_D3D11VA_VLD,
61  AV_PIX_FMT_D3D11,
62 #endif
63 #if CONFIG_VC1_D3D12VA_HWACCEL
64  AV_PIX_FMT_D3D12,
65 #endif
66 #if CONFIG_VC1_NVDEC_HWACCEL
67  AV_PIX_FMT_CUDA,
68 #endif
69 #if CONFIG_VC1_VAAPI_HWACCEL
70  AV_PIX_FMT_VAAPI,
71 #endif
72 #if CONFIG_VC1_VDPAU_HWACCEL
73  AV_PIX_FMT_VDPAU,
74 #endif
75  AV_PIX_FMT_YUV420P,
76  AV_PIX_FMT_NONE
77 };
78 
79 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
80 
81 typedef struct SpriteData {
82  /**
83  * Transform coefficients for both sprites in 16.16 fixed point format,
84  * in the order they appear in the bitstream:
85  * x scale
86  * rotation 1 (unused)
87  * x offset
88  * rotation 2 (unused)
89  * y scale
90  * y offset
91  * alpha
92  */
93  int coefs[2][7];
94 
95  int effect_type, effect_flag;
96  int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
97  int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
98 } SpriteData;
99 
100 static inline int get_fp_val(GetBitContext* gb)
101 {
102  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
103 }
104 
105 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
106 {
107  c[1] = c[3] = 0;
108 
109  switch (get_bits(gb, 2)) {
110  case 0:
111  c[0] = 1 << 16;
112  c[2] = get_fp_val(gb);
113  c[4] = 1 << 16;
114  break;
115  case 1:
116  c[0] = c[4] = get_fp_val(gb);
117  c[2] = get_fp_val(gb);
118  break;
119  case 2:
120  c[0] = get_fp_val(gb);
121  c[2] = get_fp_val(gb);
122  c[4] = get_fp_val(gb);
123  break;
124  case 3:
125  c[0] = get_fp_val(gb);
126  c[1] = get_fp_val(gb);
127  c[2] = get_fp_val(gb);
128  c[3] = get_fp_val(gb);
129  c[4] = get_fp_val(gb);
130  break;
131  }
132  c[5] = get_fp_val(gb);
133  if (get_bits1(gb))
134  c[6] = get_fp_val(gb);
135  else
136  c[6] = 1 << 16;
137 }
138 
139 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
140 {
141  AVCodecContext *avctx = v->s.avctx;
142  int sprite, i;
143 
144  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
145  vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
146  if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
147  avpriv_request_sample(avctx, "Non-zero rotation coefficients");
148  av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
149  for (i = 0; i < 7; i++)
150  av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
151  sd->coefs[sprite][i] / (1<<16),
152  (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
153  av_log(avctx, AV_LOG_DEBUG, "\n");
154  }
155 
156  skip_bits(gb, 2);
157  if (sd->effect_type = get_bits_long(gb, 30)) {
158  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
159  case 7:
160  vc1_sprite_parse_transform(gb, sd->effect_params1);
161  break;
162  case 14:
163  vc1_sprite_parse_transform(gb, sd->effect_params1);
164  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
165  break;
166  default:
167  for (i = 0; i < sd->effect_pcount1; i++)
168  sd->effect_params1[i] = get_fp_val(gb);
169  }
170  if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
171  // effect 13 is simple alpha blending and matches the opacity above
172  av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
173  for (i = 0; i < sd->effect_pcount1; i++)
174  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
175  sd->effect_params1[i] / (1 << 16),
176  (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
177  av_log(avctx, AV_LOG_DEBUG, "\n");
178  }
179 
180  sd->effect_pcount2 = get_bits(gb, 16);
181  if (sd->effect_pcount2 > 10) {
182  av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
183  return AVERROR_INVALIDDATA;
184  } else if (sd->effect_pcount2) {
185  i = -1;
186  av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
187  while (++i < sd->effect_pcount2) {
188  sd->effect_params2[i] = get_fp_val(gb);
189  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
190  sd->effect_params2[i] / (1 << 16),
191  (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
192  }
193  av_log(avctx, AV_LOG_DEBUG, "\n");
194  }
195  }
196  if (sd->effect_flag = get_bits1(gb))
197  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
198 
199  if (get_bits_count(gb) >= gb->size_in_bits +
200  (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
201  av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
202  return AVERROR_INVALIDDATA;
203  }
204  if (get_bits_count(gb) < gb->size_in_bits - 8)
205  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
206 
207  return 0;
208 }
209 
210 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
211 {
212  int i, plane, row, sprite;
213  int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
214  const uint8_t *src_h[2][2];
215  int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
216  int ysub[2];
217  MpegEncContext *s = &v->s;
218 
219  for (i = 0; i <= v->two_sprites; i++) {
220  xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
221  xadv[i] = sd->coefs[i][0];
222  if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
223  xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
224 
225  yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
226  yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
227  }
228  alpha = av_clip_uint16(sd->coefs[1][6]);
229 
230  for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
231  int width = v->output_width>>!!plane;
232 
233  for (row = 0; row < v->output_height>>!!plane; row++) {
234  uint8_t *dst = v->sprite_output_frame->data[plane] +
235  v->sprite_output_frame->linesize[plane] * row;
236 
237  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
238  const uint8_t *iplane = s->cur_pic.data[plane];
239  int iline = s->cur_pic.linesize[plane];
240  int ycoord = yoff[sprite] + yadv[sprite] * row;
241  int yline = ycoord >> 16;
242  int next_line;
243  ysub[sprite] = ycoord & 0xFFFF;
244  if (sprite) {
245  iplane = s->last_pic.data[plane];
246  iline = s->last_pic.linesize[plane];
247  }
248  next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
249  if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
250  src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
251  if (ysub[sprite])
252  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
253  } else {
254  if (sr_cache[sprite][0] != yline) {
255  if (sr_cache[sprite][1] == yline) {
256  FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
257  FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
258  } else {
259  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
260  sr_cache[sprite][0] = yline;
261  }
262  }
263  if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
264  v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
265  iplane + next_line, xoff[sprite],
266  xadv[sprite], width);
267  sr_cache[sprite][1] = yline + 1;
268  }
269  src_h[sprite][0] = v->sr_rows[sprite][0];
270  src_h[sprite][1] = v->sr_rows[sprite][1];
271  }
272  }
273 
274  if (!v->two_sprites) {
275  if (ysub[0]) {
276  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
277  } else {
278  memcpy(dst, src_h[0][0], width);
279  }
280  } else {
281  if (ysub[0] && ysub[1]) {
282  v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
283  src_h[1][0], src_h[1][1], ysub[1], alpha, width);
284  } else if (ysub[0]) {
285  v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
286  src_h[1][0], alpha, width);
287  } else if (ysub[1]) {
288  v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
289  src_h[0][0], (1<<16)-1-alpha, width);
290  } else {
291  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
292  }
293  }
294  }
295 
296  if (!plane) {
297  for (i = 0; i <= v->two_sprites; i++) {
298  xoff[i] >>= 1;
299  yoff[i] >>= 1;
300  }
301  }
302 
303  }
304 }
305 
306 
307 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
308 {
309  int ret;
310  MpegEncContext *s = &v->s;
311  AVCodecContext *avctx = s->avctx;
312  SpriteData sd;
313 
314  memset(&sd, 0, sizeof(sd));
315 
316  ret = vc1_parse_sprites(v, gb, &sd);
317  if (ret < 0)
318  return ret;
319 
320  if (!s->cur_pic.data[0]) {
321  av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
322  return AVERROR_UNKNOWN;
323  }
324 
325  if (v->two_sprites && (!s->last_pic.ptr || !s->last_pic.data[0])) {
326  av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
327  v->two_sprites = 0;
328  }
329 
330  av_frame_unref(v->sprite_output_frame);
331  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
332  return ret;
333 
334  vc1_draw_sprites(v, &sd);
335 
336  return 0;
337 }
338 
339 static void vc1_sprite_flush(AVCodecContext *avctx)
340 {
341  VC1Context *v = avctx->priv_data;
342  MpegEncContext *s = &v->s;
343  MPVWorkPicture *f = &s->cur_pic;
344  int plane, i;
345 
346  /* Windows Media Image codecs have a convergence interval of two keyframes.
347  Since we can't enforce it, clear to black the missing sprite. This is
348  wrong but it looks better than doing nothing. */
349 
350  if (f->data[0])
351  for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
352  for (i = 0; i < v->sprite_height>>!!plane; i++)
353  memset(f->data[plane] + i * f->linesize[plane],
354  plane ? 128 : 0, f->linesize[plane]);
355 }
356 
357 #endif
358 
359 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
360 {
361  MpegEncContext *s = &v->s;
362  int i, ret;
363  int mb_height = FFALIGN(s->mb_height, 2);
364 
365  /* Allocate mb bitplanes */
366  v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
367  v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
368  v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
369  v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
370  v->acpred_plane = av_malloc (s->mb_stride * mb_height);
371  v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
372  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
373  !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
374  return AVERROR(ENOMEM);
375 
376  v->n_allocated_blks = s->mb_width + 2;
377  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
378  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
379  if (!v->block || !v->cbp_base)
380  return AVERROR(ENOMEM);
381  v->cbp = v->cbp_base + 2 * s->mb_stride;
382  v->ttblk_base = av_mallocz(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
383  if (!v->ttblk_base)
384  return AVERROR(ENOMEM);
385  v->ttblk = v->ttblk_base + 2 * s->mb_stride;
386  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
387  if (!v->is_intra_base)
388  return AVERROR(ENOMEM);
389  v->is_intra = v->is_intra_base + 2 * s->mb_stride;
390  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
391  if (!v->luma_mv_base)
392  return AVERROR(ENOMEM);
393  v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
394 
395  /* allocate block type info in that way so it could be used with s->block_index[] */
396  v->mb_type_base = av_mallocz(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
397  if (!v->mb_type_base)
398  return AVERROR(ENOMEM);
399  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
400  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
401  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
402 
403  /* allocate memory to store block level MV info */
404  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
405  if (!v->blk_mv_type_base)
406  return AVERROR(ENOMEM);
407  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
408  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
409  if (!v->mv_f_base)
410  return AVERROR(ENOMEM);
411  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
412  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
413  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
414  if (!v->mv_f_next_base)
415  return AVERROR(ENOMEM);
416  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
417  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
418 
419  if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
420  for (i = 0; i < 4; i++)
421  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
422  return AVERROR(ENOMEM);
423  }
424 
425  ret = ff_intrax8_common_init(s->avctx, &v->x8,
426  s->block, s->block_last_index,
427  s->mb_width, s->mb_height);
428  if (ret < 0)
429  return ret;
430 
431  return 0;
432 }
433 
434 static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx)
435 {
436  if (avctx->codec_id == AV_CODEC_ID_MSS2)
437  return AV_PIX_FMT_YUV420P;
438 
439  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {
440  if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
441  avctx->color_range = AVCOL_RANGE_MPEG;
442  return AV_PIX_FMT_GRAY8;
443  }
444 
445  if (avctx->codec_id == AV_CODEC_ID_VC1IMAGE ||
446  avctx->codec_id == AV_CODEC_ID_WMV3IMAGE)
447  return AV_PIX_FMT_YUV420P;
448 
449  return ff_get_format(avctx, vc1_hwaccel_pixfmt_list_420);
450 }
451 
452 static void vc1_decode_reset(AVCodecContext *avctx);
453 
454 av_cold int ff_vc1_decode_init(AVCodecContext *avctx)
455 {
456  VC1Context *const v = avctx->priv_data;
457  MpegEncContext *const s = &v->s;
458  int ret;
459 
460  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
461  if (ret < 0)
462  return ret;
463 
464  ret = ff_mpv_decode_init(s, avctx);
465  if (ret < 0)
466  return ret;
467 
468  avctx->pix_fmt = vc1_get_format(avctx);
469 
470  ret = ff_mpv_common_init(s);
471  if (ret < 0)
472  return ret;
473 
474  s->y_dc_scale_table = ff_wmv3_dc_scale_table;
475  s->c_dc_scale_table = ff_wmv3_dc_scale_table;
476 
477  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,
478  ff_wmv1_scantable[0]);
479  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,
480  ff_wmv1_scantable[1]);
481 
482  ret = vc1_decode_init_alloc_tables(v);
483  if (ret < 0) {
484  vc1_decode_reset(avctx);
485  return ret;
486  }
487  return 0;
488 }
489 
490 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
491 {
492  int i;
493  for (i = 0; i < 64; i++) {
494 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
495  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
496  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
497  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
498  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
499  v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
500  }
501  v->left_blk_sh = 0;
502  v->top_blk_sh = 3;
503 }
504 
505 static av_cold void vc1_init_static(void)
506 {
507  static VLCElem vlc_table[32372];
508  VLCInitState state = VLC_INIT_STATE(vlc_table);
509 
510  VLC_INIT_STATIC_TABLE(ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
511  vc1_norm2_bits, 1, 1,
512  vc1_norm2_codes, 1, 1, 0);
513  VLC_INIT_STATIC_TABLE(ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
514  vc1_norm6_bits, 1, 1,
515  vc1_norm6_codes, 2, 2, 0);
516  VLC_INIT_STATIC_TABLE(ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
517  vc1_imode_bits, 1, 1,
518  vc1_imode_codes, 1, 1, 0);
519  for (int i = 0; i < 3; i++) {
520  ff_vc1_ttmb_vlc[i] =
521  ff_vlc_init_tables(&state, VC1_TTMB_VLC_BITS, 16,
522  vc1_ttmb_bits[i], 1, 1,
523  vc1_ttmb_codes[i], 2, 2, 0);
524  ff_vc1_ttblk_vlc[i] =
525  ff_vlc_init_tables(&state, VC1_TTBLK_VLC_BITS, 8,
526  vc1_ttblk_bits[i], 1, 1,
527  vc1_ttblk_codes[i], 1, 1, 0);
528  ff_vc1_subblkpat_vlc[i] =
529  ff_vlc_init_tables(&state, VC1_SUBBLKPAT_VLC_BITS, 15,
530  vc1_subblkpat_bits[i], 1, 1,
531  vc1_subblkpat_codes[i], 1, 1, 0);
532  }
533  for (int i = 0; i < 4; i++) {
534  ff_vc1_4mv_block_pattern_vlc[i] =
535  ff_vlc_init_tables(&state, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
536  vc1_4mv_block_pattern_bits[i], 1, 1,
537  vc1_4mv_block_pattern_codes[i], 1, 1, 0);
538  ff_vc1_cbpcy_p_vlc[i] =
539  ff_vlc_init_tables(&state, VC1_CBPCY_P_VLC_BITS, 64,
540  vc1_cbpcy_p_bits[i], 1, 1,
541  vc1_cbpcy_p_codes[i], 2, 2, 0);
542  ff_vc1_mv_diff_vlc[i] =
543  ff_vlc_init_tables(&state, VC1_MV_DIFF_VLC_BITS, 73,
544  vc1_mv_diff_bits[i], 1, 1,
545  vc1_mv_diff_codes[i], 2, 2, 0);
546  /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
547  ff_vc1_intfr_4mv_mbmode_vlc[i] =
548  ff_vlc_init_tables(&state, VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
549  vc1_intfr_4mv_mbmode_bits[i], 1, 1,
550  vc1_intfr_4mv_mbmode_codes[i], 2, 2, 0);
551  /* initialize NON-4MV MBMODE VLC tables for the same */
552  ff_vc1_intfr_non4mv_mbmode_vlc[i] =
553  ff_vlc_init_tables(&state, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
554  vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
555  vc1_intfr_non4mv_mbmode_codes[i], 1, 1, 0);
556  /* initialize interlaced MVDATA tables (1-Ref) */
557  ff_vc1_1ref_mvdata_vlc[i] =
558  ff_vlc_init_tables(&state, VC1_1REF_MVDATA_VLC_BITS, 72,
559  vc1_1ref_mvdata_bits[i], 1, 1,
560  vc1_1ref_mvdata_codes[i], 4, 4, 0);
561  /* Initialize 2MV Block pattern VLC tables */
562  ff_vc1_2mv_block_pattern_vlc[i] =
563  ff_vlc_init_tables(&state, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
564  vc1_2mv_block_pattern_bits[i], 1, 1,
565  vc1_2mv_block_pattern_codes[i], 1, 1, 0);
566  }
567  for (int i = 0; i < 8; i++) {
568  ff_vc1_ac_coeff_table[i] =
569  ff_vlc_init_tables(&state, AC_VLC_BITS, ff_vc1_ac_sizes[i],
570  &vc1_ac_tables[i][0][1], 8, 4,
571  &vc1_ac_tables[i][0][0], 8, 4, 0);
572  /* initialize interlaced MVDATA tables (2-Ref) */
573  ff_vc1_2ref_mvdata_vlc[i] =
574  ff_vlc_init_tables(&state, VC1_2REF_MVDATA_VLC_BITS, 126,
575  vc1_2ref_mvdata_bits[i], 1, 1,
576  vc1_2ref_mvdata_codes[i], 4, 4, 0);
577  /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
578  ff_vc1_icbpcy_vlc[i] =
579  ff_vlc_init_tables(&state, VC1_ICBPCY_VLC_BITS, 63,
580  vc1_icbpcy_p_bits[i], 1, 1,
581  vc1_icbpcy_p_codes[i], 2, 2, 0);
582  /* Initialize interlaced field picture MBMODE VLC tables */
583  ff_vc1_if_mmv_mbmode_vlc[i] =
584  ff_vlc_init_tables(&state, VC1_IF_MMV_MBMODE_VLC_BITS, 8,
585  vc1_if_mmv_mbmode_bits[i], 1, 1,
586  vc1_if_mmv_mbmode_codes[i], 1, 1, 0);
587  ff_vc1_if_1mv_mbmode_vlc[i] =
588  ff_vlc_init_tables(&state, VC1_IF_1MV_MBMODE_VLC_BITS, 6,
589  vc1_if_1mv_mbmode_bits[i], 1, 1,
590  vc1_if_1mv_mbmode_codes[i], 1, 1, 0);
591  }
592  ff_msmp4_vc1_vlcs_init_once();
593 }
594 
595 /**
596  * Init VC-1 specific tables and VC1Context members
597  * @param v The VC1Context to initialize
598  * @return Status
599  */
600 av_cold void ff_vc1_init_common(VC1Context *v)
601 {
602  static AVOnce init_static_once = AV_ONCE_INIT;
603  MpegEncContext *const s = &v->s;
604 
605  /* defaults */
606  v->pq = -1;
607  v->mvrange = 0; /* 7.1.1.18, p80 */
608 
609  s->avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
610  s->out_format = FMT_H263;
611 
612  s->h263_pred = 1;
613  s->msmpeg4_version = MSMP4_VC1;
614 
615  ff_vc1dsp_init(&v->vc1dsp);
616 
617  /* For error resilience */
618  ff_qpeldsp_init(&s->qdsp);
619 
620  /* VLC tables */
621  ff_thread_once(&init_static_once, vc1_init_static);
622 }
623 
624 /** Initialize a VC1/WMV3 decoder
625  * @todo TODO: Handle VC-1 IDUs (Transport level?)
626  * @todo TODO: Decipher remaining bits in extra_data
627  */
628 static av_cold int vc1_decode_init(AVCodecContext *avctx)
629 {
630  VC1Context *v = avctx->priv_data;
631  MpegEncContext *s = &v->s;
632  GetBitContext gb;
633  int ret;
634 
635  /* save the container output size for WMImage */
636  v->output_width = avctx->width;
637  v->output_height = avctx->height;
638 
639  if (!avctx->extradata_size || !avctx->extradata)
640  return AVERROR_INVALIDDATA;
641  v->s.avctx = avctx;
642 
643  ff_vc1_init_common(v);
644 
645  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
646  int count = 0;
647 
648  // looks like WMV3 has a sequence header stored in the extradata
649  // advanced sequence header may be before the first frame
650  // the last byte of the extradata is a version number, 1 for the
651  // samples we can decode
652 
653  ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);
654  if (ret < 0)
655  return ret;
656 
657  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
658  return ret;
659 
660  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
661  avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
662  return AVERROR_PATCHWELCOME;
663  }
664 
665  count = avctx->extradata_size*8 - get_bits_count(&gb);
666  if (count > 0) {
667  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
668  count, get_bits_long(&gb, FFMIN(count, 32)));
669  } else if (count < 0) {
670  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
671  }
672  } else { // VC1/WVC1/WVP2
673  const uint8_t *start = avctx->extradata;
674  const uint8_t *end = avctx->extradata + avctx->extradata_size;
675  const uint8_t *next;
676  int size, buf2_size;
677  uint8_t *buf2 = NULL;
678  int seq_initialized = 0, ep_initialized = 0;
679 
680  if (avctx->extradata_size < 16) {
681  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
682  return AVERROR_INVALIDDATA;
683  }
684 
685  buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
686  if (!buf2)
687  return AVERROR(ENOMEM);
688 
689  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
690  next = start;
691  for (; next < end; start = next) {
692  next = find_next_marker(start + 4, end);
693  size = next - start - 4;
694  if (size <= 0)
695  continue;
696  buf2_size = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
697  init_get_bits(&gb, buf2, buf2_size * 8);
698  switch (AV_RB32(start)) {
699  case VC1_CODE_SEQHDR:
700  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
701  av_free(buf2);
702  return ret;
703  }
704  seq_initialized = 1;
705  break;
706  case VC1_CODE_ENTRYPOINT:
707  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
708  av_free(buf2);
709  return ret;
710  }
711  ep_initialized = 1;
712  break;
713  }
714  }
715  av_free(buf2);
716  if (!seq_initialized || !ep_initialized) {
717  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
718  return AVERROR_INVALIDDATA;
719  }
720  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
721  }
722 
723  avctx->profile = v->profile;
724  if (v->profile == PROFILE_ADVANCED)
725  avctx->level = v->level;
726 
727  ff_blockdsp_init(&s->bdsp);
728  ff_h264chroma_init(&v->h264chroma, 8);
729 
730  avctx->has_b_frames = !!avctx->max_b_frames;
731 
732  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
733  avctx->color_primaries = v->color_prim;
734  if (v->transfer_char == 1 || v->transfer_char == 7)
735  avctx->color_trc = v->transfer_char;
736  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
737  avctx->colorspace = v->matrix_coef;
738 
739  s->mb_width = (avctx->coded_width + 15) >> 4;
740  s->mb_height = (avctx->coded_height + 15) >> 4;
741 
742  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
743  ff_vc1_init_transposed_scantables(v);
744  } else {
745  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
746  v->left_blk_sh = 3;
747  v->top_blk_sh = 0;
748  v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit;
749  v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
750  v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
751  v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
752  v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;
753  v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
754  v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
755  v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
756  }
757 
758  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
759  v->sprite_width = avctx->coded_width;
760  v->sprite_height = avctx->coded_height;
761 
762  avctx->coded_width = avctx->width = v->output_width;
763  avctx->coded_height = avctx->height = v->output_height;
764 
765  // prevent 16.16 overflows
766  if (v->sprite_width > 1 << 14 ||
767  v->sprite_height > 1 << 14 ||
768  v->output_width > 1 << 14 ||
769  v->output_height > 1 << 14) {
770  return AVERROR_INVALIDDATA;
771  }
772 
773  if ((v->sprite_width&1) || (v->sprite_height&1)) {
774  avpriv_request_sample(avctx, "odd sprites support");
775  return AVERROR_PATCHWELCOME;
776  }
777  }
778  return 0;
779 }
780 
781 static av_cold void vc1_decode_reset(AVCodecContext *avctx)
782 {
783  VC1Context *v = avctx->priv_data;
784  int i;
785 
786  av_frame_free(&v->sprite_output_frame);
787 
788  for (i = 0; i < 4; i++)
789  av_freep(&v->sr_rows[i >> 1][i & 1]);
790  ff_mpv_common_end(&v->s);
791  memset(v->s.block_index, 0, sizeof(v->s.block_index));
792  av_freep(&v->mv_type_mb_plane);
793  av_freep(&v->direct_mb_plane);
794  av_freep(&v->forward_mb_plane);
795  av_freep(&v->fieldtx_plane);
796  av_freep(&v->acpred_plane);
797  av_freep(&v->over_flags_plane);
798  av_freep(&v->mb_type_base);
799  av_freep(&v->blk_mv_type_base);
800  av_freep(&v->mv_f_base);
801  av_freep(&v->mv_f_next_base);
802  av_freep(&v->block);
803  av_freep(&v->cbp_base);
804  av_freep(&v->ttblk_base);
805  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
806  av_freep(&v->luma_mv_base);
807  ff_intrax8_common_end(&v->x8);
808 }
809 
810 /**
811  * Close a MSS2/VC1/WMV3 decoder
812  */
813 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
814 {
815  vc1_decode_reset(avctx);
816  return ff_mpv_decode_close(avctx);
817 }
818 
819 /** Decode a VC1/WMV3 frame
820  * @todo TODO: Handle VC-1 IDUs (Transport level?)
821  */
822 static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
823  int *got_frame, AVPacket *avpkt)
824 {
825  const uint8_t *buf = avpkt->data;
826  int buf_size = avpkt->size, n_slices = 0, i, ret;
827  VC1Context *v = avctx->priv_data;
828  MpegEncContext *s = &v->s;
829  uint8_t *buf2 = NULL;
830  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
831  int mb_height, n_slices1=-1;
832  struct {
833  uint8_t *buf;
834  GetBitContext gb;
835  int mby_start;
836  const uint8_t *rawbuf;
837  int raw_size;
838  } *slices = NULL, *tmp;
839  unsigned slices_allocated = 0;
840 
841  v->second_field = 0;
842 
843  if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
844  s->low_delay = 1;
845 
846  /* no supplementary picture */
847  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
848  /* special case for last picture */
849  if (s->low_delay == 0 && s->next_pic.ptr) {
850  if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)
851  return ret;
852  ff_mpv_unref_picture(&s->next_pic);
853 
854  *got_frame = 1;
855  }
856 
857  return buf_size;
858  }
859 
860  //for advanced profile we may need to parse and unescape data
861  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
862  int buf_size2 = 0;
863  size_t next_allocated = 0;
864  buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
865  if (!buf2)
866  return AVERROR(ENOMEM);
867 
868  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
869  const uint8_t *start, *end, *next;
870  int size;
871 
872  next = buf;
873  for (start = buf, end = buf + buf_size; next < end; start = next) {
874  next = find_next_marker(start + 4, end);
875  size = next - start - 4;
876  if (size <= 0) continue;
877  switch (AV_RB32(start)) {
878  case VC1_CODE_FRAME:
879  buf_start = start;
880  buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
881  break;
882  case VC1_CODE_FIELD: {
883  int buf_size3;
884  buf_start_second_field = start;
885  av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);
886  tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;
887  if (!tmp) {
888  ret = AVERROR(ENOMEM);
889  goto err;
890  }
891  slices = tmp;
892  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
893  if (!slices[n_slices].buf) {
894  ret = AVERROR(ENOMEM);
895  goto err;
896  }
897  buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,
898  slices[n_slices].buf);
899  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
900  buf_size3 << 3);
901  slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
902  slices[n_slices].rawbuf = start;
903  slices[n_slices].raw_size = size + 4;
904  n_slices1 = n_slices - 1; // index of the last slice of the first field
905  n_slices++;
906  break;
907  }
908  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
909  buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
910  init_get_bits(&s->gb, buf2, buf_size2 * 8);
911  ff_vc1_decode_entry_point(avctx, v, &s->gb);
912  break;
913  case VC1_CODE_SLICE: {
914  int buf_size3;
915  av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);
916  tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;
917  if (!tmp) {
918  ret = AVERROR(ENOMEM);
919  goto err;
920  }
921  slices = tmp;
922  slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
923  if (!slices[n_slices].buf) {
924  ret = AVERROR(ENOMEM);
925  goto err;
926  }
927  buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,
928  slices[n_slices].buf);
929  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
930  buf_size3 << 3);
931  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
932  slices[n_slices].rawbuf = start;
933  slices[n_slices].raw_size = size + 4;
934  n_slices++;
935  break;
936  }
937  }
938  }
939  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
940  const uint8_t *divider;
941  int buf_size3;
942 
943  divider = find_next_marker(buf, buf + buf_size);
944  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
945  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
946  ret = AVERROR_INVALIDDATA;
947  goto err;
948  } else { // found field marker, unescape second field
949  buf_start_second_field = divider;
950  av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);
951  tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;
952  if (!tmp) {
953  ret = AVERROR(ENOMEM);
954  goto err;
955  }
956  slices = tmp;
957  slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
958  if (!slices[n_slices].buf) {
959  ret = AVERROR(ENOMEM);
960  goto err;
961  }
962  buf_size3 = v->vc1dsp.vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
963  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
964  buf_size3 << 3);
965  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
966  slices[n_slices].rawbuf = divider;
967  slices[n_slices].raw_size = buf + buf_size - divider;
968  n_slices1 = n_slices - 1;
969  n_slices++;
970  }
971  buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, divider - buf, buf2);
972  } else {
973  buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);
974  }
975  init_get_bits(&s->gb, buf2, buf_size2*8);
976  } else{
977  ret = init_get_bits8(&s->gb, buf, buf_size);
978  if (ret < 0)
979  return ret;
980  }
981 
982  if (v->res_sprite) {
983  v->new_sprite = !get_bits1(&s->gb);
984  v->two_sprites = get_bits1(&s->gb);
985  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
986  we're using the sprite compositor. These are intentionally kept separate
987  so you can get the raw sprites by using the wmv3 decoder for WMVP or
988  the vc1 one for WVP2 */
989  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
990  if (v->new_sprite) {
991  // switch AVCodecContext parameters to those of the sprites
992  avctx->width = avctx->coded_width = v->sprite_width;
993  avctx->height = avctx->coded_height = v->sprite_height;
994  } else {
995  goto image;
996  }
997  }
998  }
999 
1000  if (s->context_initialized &&
1001  (s->width != avctx->coded_width ||
1002  s->height != avctx->coded_height)) {
1003  vc1_decode_reset(avctx);
1004  }
1005 
1006  if (!s->context_initialized) {
1007  ret = ff_vc1_decode_init(avctx);
1008  if (ret < 0)
1009  goto err;
1010 
1011  s->low_delay = !avctx->has_b_frames || v->res_sprite;
1012 
1013  if (v->profile == PROFILE_ADVANCED) {
1014  if(avctx->coded_width<=1 || avctx->coded_height<=1) {
1015  ret = AVERROR_INVALIDDATA;
1016  goto err;
1017  }
1018  s->h_edge_pos = avctx->coded_width;
1019  s->v_edge_pos = avctx->coded_height;
1020  }
1021  }
1022 
1023  // do parse frame header
1024  v->pic_header_flag = 0;
1025  v->first_pic_header_flag = 1;
1026  if (v->profile < PROFILE_ADVANCED) {
1027  if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
1028  goto err;
1029  }
1030  } else {
1031  if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1032  goto err;
1033  }
1034  }
1035  v->first_pic_header_flag = 0;
1036 
1037  if (avctx->debug & FF_DEBUG_PICT_INFO)
1038  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
1039 
1040  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
1041  && s->pict_type != AV_PICTURE_TYPE_I) {
1042  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
1043  ret = AVERROR_INVALIDDATA;
1044  goto err;
1045  }
1046  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
1047  && v->field_mode) {
1048  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
1049  ret = AVERROR_INVALIDDATA;
1050  goto err;
1051  }
1052  if ((s->mb_height >> v->field_mode) == 0) {
1053  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
1054  ret = AVERROR_INVALIDDATA;
1055  goto err;
1056  }
1057 
1058  /* skip B-frames if we don't have reference frames */
1059  if (!s->last_pic.ptr && s->pict_type == AV_PICTURE_TYPE_B) {
1060  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
1061  goto end;
1062  }
1063  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
1064  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
1065  avctx->skip_frame >= AVDISCARD_ALL) {
1066  goto end;
1067  }
1068 
1069  if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
1070  goto err;
1071  }
1072 
1073  v->s.cur_pic.ptr->field_picture = v->field_mode;
1074  v->s.cur_pic.ptr->f->flags |= AV_FRAME_FLAG_INTERLACED * (v->fcm != PROGRESSIVE);
1075  v->s.cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!v->tff;
1076  v->last_interlaced = v->s.last_pic.ptr ? v->s.last_pic.ptr->f->flags & AV_FRAME_FLAG_INTERLACED : 0;
1077  v->next_interlaced = v->s.next_pic.ptr ? v->s.next_pic.ptr->f->flags & AV_FRAME_FLAG_INTERLACED : 0;
1078 
1079  // process pulldown flags
1080  s->cur_pic.ptr->f->repeat_pict = 0;
1081  // Pulldown flags are only valid when 'broadcast' has been set.
1082  if (v->rff) {
1083  // repeat field
1084  s->cur_pic.ptr->f->repeat_pict = 1;
1085  } else if (v->rptfrm) {
1086  // repeat frames
1087  s->cur_pic.ptr->f->repeat_pict = v->rptfrm * 2;
1088  }
1089 
1090  if (avctx->hwaccel) {
1091  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1092  s->mb_y = 0;
1093  if (v->field_mode && buf_start_second_field) {
1094  // decode first field
1095  s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
1096  ret = hwaccel->start_frame(avctx, buf_start,
1097  buf_start_second_field - buf_start);
1098  if (ret < 0)
1099  goto err;
1100 
1101  if (n_slices1 == -1) {
1102  // no slices, decode the field as-is
1103  ret = hwaccel->decode_slice(avctx, buf_start,
1104  buf_start_second_field - buf_start);
1105  if (ret < 0)
1106  goto err;
1107  } else {
1108  ret = hwaccel->decode_slice(avctx, buf_start,
1109  slices[0].rawbuf - buf_start);
1110  if (ret < 0)
1111  goto err;
1112 
1113  for (i = 0 ; i < n_slices1 + 1; i++) {
1114  s->gb = slices[i].gb;
1115  s->mb_y = slices[i].mby_start;
1116 
1117  v->pic_header_flag = get_bits1(&s->gb);
1118  if (v->pic_header_flag) {
1119  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1120  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1121  ret = AVERROR_INVALIDDATA;
1122  if (avctx->err_recognition & AV_EF_EXPLODE)
1123  goto err;
1124  continue;
1125  }
1126  }
1127 
1128  ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,
1129  slices[i].raw_size);
1130  if (ret < 0)
1131  goto err;
1132  }
1133  }
1134 
1135  if ((ret = hwaccel->end_frame(avctx)) < 0)
1136  goto err;
1137 
1138  // decode second field
1139  s->gb = slices[n_slices1 + 1].gb;
1140  s->mb_y = slices[n_slices1 + 1].mby_start;
1141  s->picture_structure = PICT_TOP_FIELD + v->tff;
1142  v->second_field = 1;
1143  v->pic_header_flag = 0;
1144  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1145  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
1146  ret = AVERROR_INVALIDDATA;
1147  goto err;
1148  }
1149  v->s.cur_pic.ptr->f->pict_type = v->s.pict_type;
1150 
1151  ret = hwaccel->start_frame(avctx, buf_start_second_field,
1152  (buf + buf_size) - buf_start_second_field);
1153  if (ret < 0)
1154  goto err;
1155 
1156  if (n_slices - n_slices1 == 2) {
1157  // no slices, decode the field as-is
1158  ret = hwaccel->decode_slice(avctx, buf_start_second_field,
1159  (buf + buf_size) - buf_start_second_field);
1160  if (ret < 0)
1161  goto err;
1162  } else {
1163  ret = hwaccel->decode_slice(avctx, buf_start_second_field,
1164  slices[n_slices1 + 2].rawbuf - buf_start_second_field);
1165  if (ret < 0)
1166  goto err;
1167 
1168  for (i = n_slices1 + 2; i < n_slices; i++) {
1169  s->gb = slices[i].gb;
1170  s->mb_y = slices[i].mby_start;
1171 
1172  v->pic_header_flag = get_bits1(&s->gb);
1173  if (v->pic_header_flag) {
1174  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1175  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1176  ret = AVERROR_INVALIDDATA;
1177  if (avctx->err_recognition & AV_EF_EXPLODE)
1178  goto err;
1179  continue;
1180  }
1181  }
1182 
1183  ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,
1184  slices[i].raw_size);
1185  if (ret < 0)
1186  goto err;
1187  }
1188  }
1189 
1190  if ((ret = hwaccel->end_frame(avctx)) < 0)
1191  goto err;
1192  } else {
1193  s->picture_structure = PICT_FRAME;
1194  ret = hwaccel->start_frame(avctx, buf_start,
1195  (buf + buf_size) - buf_start);
1196  if (ret < 0)
1197  goto err;
1198 
1199  if (n_slices == 0) {
1200  // no slices, decode the frame as-is
1201  ret = hwaccel->decode_slice(avctx, buf_start,
1202  (buf + buf_size) - buf_start);
1203  if (ret < 0)
1204  goto err;
1205  } else {
1206  // decode the frame part as the first slice
1207  ret = hwaccel->decode_slice(avctx, buf_start,
1208  slices[0].rawbuf - buf_start);
1209  if (ret < 0)
1210  goto err;
1211 
1212  // and process the slices as additional slices afterwards
1213  for (i = 0 ; i < n_slices; i++) {
1214  s->gb = slices[i].gb;
1215  s->mb_y = slices[i].mby_start;
1216 
1217  v->pic_header_flag = get_bits1(&s->gb);
1218  if (v->pic_header_flag) {
1219  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1220  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1221  ret = AVERROR_INVALIDDATA;
1222  if (avctx->err_recognition & AV_EF_EXPLODE)
1223  goto err;
1224  continue;
1225  }
1226  }
1227 
1228  ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,
1229  slices[i].raw_size);
1230  if (ret < 0)
1231  goto err;
1232  }
1233  }
1234  if ((ret = hwaccel->end_frame(avctx)) < 0)
1235  goto err;
1236  }
1237  } else {
1238  int header_ret = 0;
1239 
1240  ff_mpeg_er_frame_start(s);
1241 
1242  v->end_mb_x = s->mb_width;
1243  if (v->field_mode) {
1244  s->cur_pic.linesize[0] <<= 1;
1245  s->cur_pic.linesize[1] <<= 1;
1246  s->cur_pic.linesize[2] <<= 1;
1247  s->linesize <<= 1;
1248  s->uvlinesize <<= 1;
1249  }
1250  mb_height = s->mb_height >> v->field_mode;
1251 
1252  av_assert0 (mb_height > 0);
1253 
1254  for (i = 0; i <= n_slices; i++) {
1255  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1256  if (v->field_mode <= 0) {
1257  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1258  "picture boundary (%d >= %d)\n", i,
1259  slices[i - 1].mby_start, mb_height);
1260  continue;
1261  }
1262  v->second_field = 1;
1263  av_assert0((s->mb_height & 1) == 0);
1264  v->blocks_off = s->b8_stride * (s->mb_height&~1);
1265  v->mb_off = s->mb_stride * s->mb_height >> 1;
1266  } else {
1267  v->second_field = 0;
1268  v->blocks_off = 0;
1269  v->mb_off = 0;
1270  }
1271  if (i) {
1272  v->pic_header_flag = 0;
1273  if (v->field_mode && i == n_slices1 + 2) {
1274  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1275  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1276  ret = AVERROR_INVALIDDATA;
1277  if (avctx->err_recognition & AV_EF_EXPLODE)
1278  goto err;
1279  continue;
1280  }
1281  } else if (get_bits1(&s->gb)) {
1282  v->pic_header_flag = 1;
1283  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1284  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1285  ret = AVERROR_INVALIDDATA;
1286  if (avctx->err_recognition & AV_EF_EXPLODE)
1287  goto err;
1288  continue;
1289  }
1290  }
1291  }
1292  if (header_ret < 0)
1293  continue;
1294  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1295  if (!v->field_mode || v->second_field)
1296  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1297  else {
1298  if (i >= n_slices) {
1299  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1300  continue;
1301  }
1302  s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1303  }
1304  if (s->end_mb_y <= s->start_mb_y) {
1305  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1306  continue;
1307  }
1308  if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1309  (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1310  !v->cbpcy_vlc) {
1311  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1312  continue;
1313  }
1314  ff_vc1_decode_blocks(v);
1315  if (i != n_slices) {
1316  s->gb = slices[i].gb;
1317  }
1318  }
1319  if (v->field_mode) {
1320  v->second_field = 0;
1321  s->cur_pic.linesize[0] >>= 1;
1322  s->cur_pic.linesize[1] >>= 1;
1323  s->cur_pic.linesize[2] >>= 1;
1324  s->linesize >>= 1;
1325  s->uvlinesize >>= 1;
1326  if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1327  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1328  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1329  }
1330  }
1331  ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1332  get_bits_count(&s->gb), s->gb.size_in_bits);
1333 // if (get_bits_count(&s->gb) > buf_size * 8)
1334 // return -1;
1335  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1336  ret = AVERROR_INVALIDDATA;
1337  goto err;
1338  }
1339  if ( !v->field_mode
1340  && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1341  && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1342  ff_er_frame_end(&s->er, NULL);
1343  }
1344 
1345  ff_mpv_frame_end(s);
1346 
1347  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1348 image:
1349  avctx->width = avctx->coded_width = v->output_width;
1350  avctx->height = avctx->coded_height = v->output_height;
1351  if (avctx->skip_frame >= AVDISCARD_NONREF)
1352  goto end;
1353  if (!v->sprite_output_frame &&
1354  !(v->sprite_output_frame = av_frame_alloc())) {
1355  ret = AVERROR(ENOMEM);
1356  goto err;
1357  }
1358 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1359  if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1360  goto err;
1361 #endif
1362  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1363  goto err;
1364  *got_frame = 1;
1365  } else {
1366  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1367  if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0)
1368  goto err;
1369  if (!v->field_mode)
1370  ff_print_debug_info(s, s->cur_pic.ptr, pict);
1371  *got_frame = 1;
1372  } else if (s->last_pic.ptr) {
1373  if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0)
1374  goto err;
1375  if (!v->field_mode)
1376  ff_print_debug_info(s, s->last_pic.ptr, pict);
1377  *got_frame = 1;
1378  }
1379  }
1380 
1381 end:
1382  av_free(buf2);
1383  for (i = 0; i < n_slices; i++)
1384  av_free(slices[i].buf);
1385  av_free(slices);
1386  return buf_size;
1387 
1388 err:
1389  av_free(buf2);
1390  for (i = 0; i < n_slices; i++)
1391  av_free(slices[i].buf);
1392  av_free(slices);
1393  return ret;
1394 }
1395 
1396 
1397 const FFCodec ff_vc1_decoder = {
1398  .p.name = "vc1",
1399  CODEC_LONG_NAME("SMPTE VC-1"),
1400  .p.type = AVMEDIA_TYPE_VIDEO,
1401  .p.id = AV_CODEC_ID_VC1,
1402  .priv_data_size = sizeof(VC1Context),
1403  .init = vc1_decode_init,
1404  .close = ff_vc1_decode_end,
1405  FF_CODEC_DECODE_CB(vc1_decode_frame),
1406  .flush = ff_mpeg_flush,
1407  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1408  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1409 #if CONFIG_VC1_DXVA2_HWACCEL
1410  HWACCEL_DXVA2(vc1),
1411 #endif
1412 #if CONFIG_VC1_D3D11VA_HWACCEL
1413  HWACCEL_D3D11VA(vc1),
1414 #endif
1415 #if CONFIG_VC1_D3D11VA2_HWACCEL
1416  HWACCEL_D3D11VA2(vc1),
1417 #endif
1418 #if CONFIG_VC1_D3D12VA_HWACCEL
1419  HWACCEL_D3D12VA(vc1),
1420 #endif
1421 #if CONFIG_VC1_NVDEC_HWACCEL
1422  HWACCEL_NVDEC(vc1),
1423 #endif
1424 #if CONFIG_VC1_VAAPI_HWACCEL
1425  HWACCEL_VAAPI(vc1),
1426 #endif
1427 #if CONFIG_VC1_VDPAU_HWACCEL
1428  HWACCEL_VDPAU(vc1),
1429 #endif
1430  NULL
1431  },
1432  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1433 };
1434 
1435 #if CONFIG_WMV3_DECODER
1436 const FFCodec ff_wmv3_decoder = {
1437  .p.name = "wmv3",
1438  CODEC_LONG_NAME("Windows Media Video 9"),
1439  .p.type = AVMEDIA_TYPE_VIDEO,
1440  .p.id = AV_CODEC_ID_WMV3,
1441  .priv_data_size = sizeof(VC1Context),
1442  .init = vc1_decode_init,
1443  .close = ff_vc1_decode_end,
1444  FF_CODEC_DECODE_CB(vc1_decode_frame),
1445  .flush = ff_mpeg_flush,
1446  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1447  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1448 #if CONFIG_WMV3_DXVA2_HWACCEL
1449  HWACCEL_DXVA2(wmv3),
1450 #endif
1451 #if CONFIG_WMV3_D3D11VA_HWACCEL
1452  HWACCEL_D3D11VA(wmv3),
1453 #endif
1454 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1455  HWACCEL_D3D11VA2(wmv3),
1456 #endif
1457 #if CONFIG_WMV3_D3D12VA_HWACCEL
1458  HWACCEL_D3D12VA(wmv3),
1459 #endif
1460 #if CONFIG_WMV3_NVDEC_HWACCEL
1461  HWACCEL_NVDEC(wmv3),
1462 #endif
1463 #if CONFIG_WMV3_VAAPI_HWACCEL
1464  HWACCEL_VAAPI(wmv3),
1465 #endif
1466 #if CONFIG_WMV3_VDPAU_HWACCEL
1467  HWACCEL_VDPAU(wmv3),
1468 #endif
1469  NULL
1470  },
1471  .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1472 };
1473 #endif
1474 
1475 #if CONFIG_WMV3IMAGE_DECODER
1476 const FFCodec ff_wmv3image_decoder = {
1477  .p.name = "wmv3image",
1478  CODEC_LONG_NAME("Windows Media Video 9 Image"),
1479  .p.type = AVMEDIA_TYPE_VIDEO,
1480  .p.id = AV_CODEC_ID_WMV3IMAGE,
1481  .priv_data_size = sizeof(VC1Context),
1482  .init = vc1_decode_init,
1483  .close = ff_vc1_decode_end,
1484  FF_CODEC_DECODE_CB(vc1_decode_frame),
1485  .p.capabilities = AV_CODEC_CAP_DR1,
1486  .flush = vc1_sprite_flush,
1487 };
1488 #endif
1489 
1490 #if CONFIG_VC1IMAGE_DECODER
1491 const FFCodec ff_vc1image_decoder = {
1492  .p.name = "vc1image",
1493  CODEC_LONG_NAME("Windows Media Video 9 Image v2"),
1494  .p.type = AVMEDIA_TYPE_VIDEO,
1495  .p.id = AV_CODEC_ID_VC1IMAGE,
1496  .priv_data_size = sizeof(VC1Context),
1497  .init = vc1_decode_init,
1498  .close = ff_vc1_decode_end,
1499  FF_CODEC_DECODE_CB(vc1_decode_frame),
1500  .p.capabilities = AV_CODEC_CAP_DR1,
1501  .flush = vc1_sprite_flush,
1502 };
1503 #endif
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:80
av_size_mult
int av_size_mult(size_t a, size_t b, size_t *r)
Multiply two size_t values checking for overflow.
Definition: mem.c:567
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:687
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:1445
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:215
ff_simple_idct44_add
void ff_simple_idct44_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:224
VC1Context::new_sprite
int new_sprite
Frame decoding info for sprite modes.
Definition: vc1.h:376
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
vc1_cbpcy_p_bits
static const uint8_t vc1_cbpcy_p_bits[4][64]
Definition: vc1_vlc_data.h:501
av_clip
#define av_clip
Definition: common.h:100
VC1Context::two_sprites
int two_sprites
Definition: vc1.h:377
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:699
AC_VLC_BITS
#define AC_VLC_BITS
Definition: intrax8.c:42
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1277
vc1_hwaccel_pixfmt_list_420
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:55
ff_vc1image_decoder
const FFCodec ff_vc1image_decoder
VC1Context::cbp
uint32_t * cbp
Definition: vc1.h:389
vc1_intfr_non4mv_mbmode_bits
static const uint8_t vc1_intfr_non4mv_mbmode_bits[4][9]
Definition: vc1_vlc_data.h:112
VC1Context::end_mb_x
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:396
VC1Context::interlace
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:199
thread.h
vc1.h
vc1_subblkpat_codes
static const uint8_t vc1_subblkpat_codes[3][15]
Definition: vc1_vlc_data.h:744
MpegEncContext::block_index
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:292
VC1DSPContext::vc1_inv_trans_4x4
void(* vc1_inv_trans_4x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:40
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1438
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
vc1_2ref_mvdata_bits
static const uint8_t vc1_2ref_mvdata_bits[8][126]
Definition: vc1_vlc_data.h:389
ff_qpeldsp_init
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:784
vc1_2mv_block_pattern_bits
static const uint8_t vc1_2mv_block_pattern_bits[4][4]
Definition: vc1_vlc_data.h:85
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:111
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
VC1Context::sprite_height
int sprite_height
Definition: vc1.h:379
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:410
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:692
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:64
ff_simple_idct84_add
void ff_simple_idct84_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:194
AVPacket::data
uint8_t * data
Definition: packet.h:539
vc1_intfr_4mv_mbmode_bits
static const uint8_t vc1_intfr_4mv_mbmode_bits[4][15]
Definition: vc1_vlc_data.h:97
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
VC1_SUBBLKPAT_VLC_BITS
#define VC1_SUBBLKPAT_VLC_BITS
Definition: vc1data.h:79
VC1Context::cbp_base
uint32_t * cbp_base
Definition: vc1.h:389
VC1Context::mv_type_mb_plane
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:284
VC1Context::last_interlaced
int last_interlaced
Definition: vc1.h:296
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:254
FFCodec
Definition: codec_internal.h:127
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
VC1_CBPCY_P_VLC_BITS
#define VC1_CBPCY_P_VLC_BITS
Definition: vc1data.h:69
VC1DSPContext::vc1_inv_trans_8x8_dc
void(* vc1_inv_trans_8x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:41
mpegvideo.h
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:91
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:690
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
VC1Context::next_interlaced
int next_interlaced
whether last_pic, next_pic is interlaced
Definition: vc1.h:296
VC1DSPContext::vc1_inv_trans_4x4_dc
void(* vc1_inv_trans_4x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:44
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
vc1_norm2_bits
static const uint8_t vc1_norm2_bits[4]
Definition: vc1_vlc_data.h:48
VC1Context::output_height
int output_height
Definition: vc1.h:379
VC1Context::luma_mv
int16_t((* luma_mv)[2]
Definition: vc1.h:391
mpegutils.h
vc1_ttmb_bits
static const uint8_t vc1_ttmb_bits[3][16]
Definition: vc1_vlc_data.h:701
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
vc1_intfr_4mv_mbmode_codes
static const uint16_t vc1_intfr_4mv_mbmode_codes[4][15]
Definition: vc1_vlc_data.h:90
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1415
VC1Context::rptfrm
uint8_t rptfrm
Definition: vc1.h:311
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:674
ff_vc1_parse_frame_header
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:624
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
state
static struct @472 state
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:206
FFHWAccel
Definition: hwaccel_internal.h:34
VC1_INTFR_NON4MV_MBMODE_VLC_BITS
#define VC1_INTFR_NON4MV_MBMODE_VLC_BITS
Definition: vc1data.h:83
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1841
ff_vc1_if_1mv_mbmode_vlc
const VLCElem * ff_vc1_if_1mv_mbmode_vlc[8]
Definition: vc1data.c:120
GetBitContext
Definition: get_bits.h:108
vc1_decode_init
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:628
VC1Context::first_pic_header_flag
int first_pic_header_flag
Definition: vc1.h:366
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:274
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
ff_vc1_norm6_vlc
VLCElem ff_vc1_norm6_vlc[556]
Definition: vc1data.c:107
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:334
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:647
VC1Context::n_allocated_blks
int n_allocated_blks
Definition: vc1.h:388
VC1_TTMB_VLC_BITS
#define VC1_TTMB_VLC_BITS
Definition: vc1data.h:65
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:151
VC1_IF_MMV_MBMODE_VLC_BITS
#define VC1_IF_MMV_MBMODE_VLC_BITS
Definition: vc1data.h:85
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:774
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:685
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
mpegvideodec.h
vc1_ttblk_codes
static const uint8_t vc1_ttblk_codes[3][8]
Definition: vc1_vlc_data.h:732
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
ff_wmv3_dc_scale_table
const uint8_t ff_wmv3_dc_scale_table[32]
Definition: vc1data.c:173
VC1DSPContext::vc1_inv_trans_8x4_dc
void(* vc1_inv_trans_8x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:42
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
vc1_1ref_mvdata_bits
static const uint8_t vc1_1ref_mvdata_bits[4][72]
Definition: vc1_vlc_data.h:214
ff_msmp4_vc1_vlcs_init_once
av_cold void ff_msmp4_vc1_vlcs_init_once(void)
Definition: msmpeg4_vc1_data.c:56
vc1_decode_reset
static void vc1_decode_reset(AVCodecContext *avctx)
Definition: vc1dec.c:781
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:212
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
vc1_2mv_block_pattern_codes
static const uint8_t vc1_2mv_block_pattern_codes[4][4]
Definition: vc1_vlc_data.h:81
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:538
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:737
ff_vc1_2mv_block_pattern_vlc
const VLCElem * ff_vc1_2mv_block_pattern_vlc[4]
Definition: vc1data.c:114
ff_er_frame_end
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
Definition: error_resilience.c:896
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
ff_vc1_decoder
const FFCodec ff_vc1_decoder
Definition: vc1dec.c:1397
VC1_CODE_SLICE
@ VC1_CODE_SLICE
Definition: vc1_common.h:36
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
VC1Context::mb_type
uint8_t * mb_type[3]
Definition: vc1.h:262
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:134
s
#define s(width, name)
Definition: cbs_vp9.c:198
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
vc1_init_static
static av_cold void vc1_init_static(void)
Definition: vc1dec.c:505
vc1_if_mmv_mbmode_codes
static const uint8_t vc1_if_mmv_mbmode_codes[8][8]
Definition: vc1_vlc_data.h:121
MPVWorkPicture::ptr
MPVPicture * ptr
RefStruct reference.
Definition: mpegpicture.h:99
VC1Context::mv_f
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:348
vc1_ac_tables
static const uint32_t vc1_ac_tables[AC_MODES][186][2]
Definition: vc1_vlc_data.h:838
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
vc1_subblkpat_bits
static const uint8_t vc1_subblkpat_bits[3][15]
Definition: vc1_vlc_data.h:749
VC1Context::x8
IntraX8Context x8
Definition: vc1.h:175
VC1Context::over_flags_plane
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:323
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:49
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ff_simple_idct48_add
void ff_simple_idct48_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:209
PROFILE_ADVANCED
@ PROFILE_ADVANCED
Definition: vc1_common.h:52
vc1_imode_bits
static const uint8_t vc1_imode_bits[7]
Definition: vc1_vlc_data.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
vc1_norm2_codes
static const uint8_t vc1_norm2_codes[4]
Definition: vc1_vlc_data.h:45
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
decode.h
get_bits.h
simple_idct.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:73
AV_CODEC_ID_VC1IMAGE
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:204
vc1_norm6_bits
static const uint8_t vc1_norm6_bits[64]
Definition: vc1_vlc_data.h:59
MpegEncContext::cur_pic
MPVWorkPicture cur_pic
copy of the current picture structure.
Definition: mpegvideo.h:177
ff_intrax8_common_init
av_cold int ff_intrax8_common_init(AVCodecContext *avctx, IntraX8Context *w, int16_t(*block)[64], int block_last_index[12], int mb_width, int mb_height)
Initialize IntraX8 frame decoder.
Definition: intrax8.c:689
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
ff_vc1_ttblk_vlc
const VLCElem * ff_vc1_ttblk_vlc[3]
Definition: vc1data.c:115
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
VC1Context::top_blk_sh
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:238
FMT_H263
@ FMT_H263
Definition: mpegvideo.h:65
ff_mpv_unref_picture
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition: mpegpicture.c:98
VC1_INTFR_4MV_MBMODE_VLC_BITS
#define VC1_INTFR_4MV_MBMODE_VLC_BITS
Definition: vc1data.h:81
VC1Context::pq
uint8_t pq
Definition: vc1.h:236
VC1_1REF_MVDATA_VLC_BITS
#define VC1_1REF_MVDATA_VLC_BITS
Definition: vc1data.h:89
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
ff_wmv3_decoder
const FFCodec ff_wmv3_decoder
AV_CODEC_ID_WMV3
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:123
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
VC1Context::forward_mb_plane
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:286
NULL
#define NULL
Definition: coverity.c:32
ff_vc1_cbpcy_p_vlc
const VLCElem * ff_vc1_cbpcy_p_vlc[4]
Definition: vc1data.c:111
ff_vc1_if_mmv_mbmode_vlc
const VLCElem * ff_vc1_if_mmv_mbmode_vlc[8]
Definition: vc1data.c:119
ff_simple_idct_add_int16_8bit
void ff_simple_idct_add_int16_8bit(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
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:709
VC1Context::direct_mb_plane
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:285
VC1DSPContext::vc1_inv_trans_8x4
void(* vc1_inv_trans_8x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:38
ff_vc1_2ref_mvdata_vlc
const VLCElem * ff_vc1_2ref_mvdata_vlc[8]
Definition: vc1data.c:122
hwaccel_internal.h
ff_vc1_init_transposed_scantables
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:490
MpegEncContext::next_pic
MPVWorkPicture next_pic
copy of the next picture structure.
Definition: mpegvideo.h:165
vc1_cbpcy_p_codes
static const uint16_t vc1_cbpcy_p_codes[4][64]
Definition: vc1_vlc_data.h:474
VC1Context::field_mode
int field_mode
1 for interlaced field pictures
Definition: vc1.h:350
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:754
ff_vc1_decode_blocks
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2981
VC1Context::blk_mv_type_base
uint8_t * blk_mv_type_base
Definition: vc1.h:347
ff_intrax8_common_end
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:728
VC1Context::mvrange
uint8_t mvrange
Ranges:
Definition: vc1.h:280
VC1_CODE_SEQHDR
@ VC1_CODE_SEQHDR
Definition: vc1_common.h:40
MPVPicture::field_picture
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:82
VC1Context::block
int16_t(* block)[6][64]
Definition: vc1.h:387
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
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
VC1Context::cbpcy_vlc
const VLCElem * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:282
vc1_intfr_non4mv_mbmode_codes
static const uint8_t vc1_intfr_non4mv_mbmode_codes[4][9]
Definition: vc1_vlc_data.h:105
abs
#define abs(x)
Definition: cuda_runtime.h:35
VC1Context::luma_mv_base
int16_t(* luma_mv_base)[2]
Definition: vc1.h:391
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
VC1_ICBPCY_VLC_BITS
#define VC1_ICBPCY_VLC_BITS
Definition: vc1data.h:71
VC1_CODE_FRAME
@ VC1_CODE_FRAME
Definition: vc1_common.h:38
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1802
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:699
AVOnce
#define AVOnce
Definition: thread.h:202
VC1DSPContext::vc1_inv_trans_4x8_dc
void(* vc1_inv_trans_4x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:43
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:344
ff_vc1_init_common
av_cold void ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1dec.c:600
ff_vc1_adv_interlaced_8x8_zz
const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]
Definition: vc1data.c:207
ff_vc1dsp_init
av_cold void ff_vc1dsp_init(VC1DSPContext *dsp)
Definition: vc1dsp.c:974
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:220
ff_vc1_icbpcy_vlc
const VLCElem * ff_vc1_icbpcy_vlc[8]
Definition: vc1data.c:112
VC1Context::mv_f_next
uint8_t * mv_f_next[2]
Definition: vc1.h:349
f
f
Definition: af_crystalizer.c:122
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:512
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
VC1_TTBLK_VLC_BITS
#define VC1_TTBLK_VLC_BITS
Definition: vc1data.h:77
VC1Context::is_intra
uint8_t * is_intra
Definition: vc1.h:390
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:322
AVPacket::size
int size
Definition: packet.h:540
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:94
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:401
codec_internal.h
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
ff_vc1_1ref_mvdata_vlc
const VLCElem * ff_vc1_1ref_mvdata_vlc[4]
Definition: vc1data.c:121
VC1Context::ttblk_base
int * ttblk_base
Definition: vc1.h:257
VC1Context::mb_off
int mb_off
Definition: vc1.h:362
ff_wmv3image_decoder
const FFCodec ff_wmv3image_decoder
ff_vc1_mv_diff_vlc
const VLCElem * ff_vc1_mv_diff_vlc[4]
Definition: vc1data.c:110
vc1_norm6_codes
static const uint16_t vc1_norm6_codes[64]
Definition: vc1_vlc_data.h:52
size
int size
Definition: twinvq_data.h:10344
VC1Context::zzi_8x8
uint8_t zzi_8x8[64]
Definition: vc1.h:346
VLCElem
Definition: vlc.h:32
vc1_if_1mv_mbmode_codes
static const uint8_t vc1_if_1mv_mbmode_codes[8][6]
Definition: vc1_vlc_data.h:143
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
ff_vc1_intfr_4mv_mbmode_vlc
const VLCElem * ff_vc1_intfr_4mv_mbmode_vlc[4]
Definition: vc1data.c:117
VC1Context::sprite_width
int sprite_width
Definition: vc1.h:379
ff_vc1_ac_coeff_table
const VLCElem * ff_vc1_ac_coeff_table[8]
Definition: vc1data.c:124
vc1_ttblk_bits
static const uint8_t vc1_ttblk_bits[3][8]
Definition: vc1_vlc_data.h:737
AVCodecHWConfigInternal
Definition: hwconfig.h:25
vc1_icbpcy_p_bits
static const uint8_t vc1_icbpcy_p_bits[8][63]
Definition: vc1_vlc_data.h:612
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_dec.c:344
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:449
vc1data.h
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:78
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
attributes.h
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
VC1DSPContext::vc1_inv_trans_8x8
void(* vc1_inv_trans_8x8)(int16_t *b)
Definition: vc1dsp.h:37
VC1Context::sr_rows
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition: vc1.h:380
VC1_IMODE_VLC_BITS
#define VC1_IMODE_VLC_BITS
Definition: vc1data.h:58
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
AV_CODEC_ID_MSS2
@ AV_CODEC_ID_MSS2
Definition: codec_id.h:221
VC1_IF_1MV_MBMODE_VLC_BITS
#define VC1_IF_1MV_MBMODE_VLC_BITS
Definition: vc1data.h:87
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
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:40
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: mpegvideo.c:293
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:403
vc1_get_format
static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx)
Definition: vc1dec.c:434
ff_simple_idct_int16_8bit
void ff_simple_idct_int16_8bit(int16_t *block)
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
vc1_if_1mv_mbmode_bits
static const uint8_t vc1_if_1mv_mbmode_bits[8][6]
Definition: vc1_vlc_data.h:153
ff_vc1_intfr_non4mv_mbmode_vlc
const VLCElem * ff_vc1_intfr_non4mv_mbmode_vlc[4]
Definition: vc1data.c:118
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
VC1DSPContext::vc1_unescape_buffer
int(* vc1_unescape_buffer)(const uint8_t *src, int size, uint8_t *dst)
Definition: vc1dsp.h:85
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:537
vc1_4mv_block_pattern_bits
static const uint8_t vc1_4mv_block_pattern_bits[4][16]
Definition: vc1_vlc_data.h:73
VC1_4MV_BLOCK_PATTERN_VLC_BITS
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.h:73
ff_vc1_decode_entry_point
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:501
ff_vc1_parse_frame_header_adv
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:846
VC1Context::s
MpegEncContext s
Definition: vc1.h:174
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vc1_ac_sizes
const int ff_vc1_ac_sizes[AC_MODES]
Definition: vc1_vlc_data.h:1059
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:623
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:256
VC1Context::pic_header_flag
int pic_header_flag
Definition: vc1.h:367
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
VC1Context::ttblk
int * ttblk
Transform type at the block level.
Definition: vc1.h:257
MpegEncContext::last_pic
MPVWorkPicture last_pic
copy of the previous picture structure.
Definition: mpegvideo.h:159
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
VC1_NORM6_VLC_BITS
#define VC1_NORM6_VLC_BITS
Definition: vc1data.h:62
AVCodecContext::height
int height
Definition: avcodec.h:632
VC1Context::is_intra_base
uint8_t * is_intra_base
Definition: vc1.h:390
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:671
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:669
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:716
avcodec.h
VC1Context::second_field
int second_field
Definition: vc1.h:352
vc1_if_mmv_mbmode_bits
static const uint8_t vc1_if_mmv_mbmode_bits[8][8]
Definition: vc1_vlc_data.h:131
ret
ret
Definition: filter_design.txt:187
close
static void close(AVCodecParserContext *s)
Definition: ffv1_parser.c:73
vc1_icbpcy_p_codes
static const uint16_t vc1_icbpcy_p_codes[8][63]
Definition: vc1_vlc_data.h:529
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
VC1Context::sprite_output_frame
AVFrame * sprite_output_frame
Definition: vc1.h:378
VC1Context::output_width
int output_width
Definition: vc1.h:379
ff_mpv_decode_init
int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:46
VC1Context::color_prim
int color_prim
8 bits, chroma coordinates of the color primaries
Definition: vc1.h:204
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
VC1Context::mv_f_next_base
uint8_t * mv_f_next_base
Definition: vc1.h:349
vc1_mv_diff_codes
static const uint16_t vc1_mv_diff_codes[4][73]
Definition: vc1_vlc_data.h:756
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
MPVPicture::f
struct AVFrame * f
Definition: mpegpicture.h:59
ff_vc1_subblkpat_vlc
const VLCElem * ff_vc1_subblkpat_vlc[3]
Definition: vc1data.c:116
VC1_2MV_BLOCK_PATTERN_VLC_BITS
#define VC1_2MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.h:75
AVCodecContext
main external API structure.
Definition: avcodec.h:451
ff_vc1_imode_vlc
VLCElem ff_vc1_imode_vlc[1<< VC1_IMODE_VLC_BITS]
Definition: vc1data.c:105
VC1Context::p_frame_skipped
int p_frame_skipped
Definition: vc1.h:383
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
vc1_4mv_block_pattern_codes
static const uint8_t vc1_4mv_block_pattern_codes[4][16]
Definition: vc1_vlc_data.h:67
VC1Context::tff
uint8_t tff
Definition: vc1.h:311
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
VLC_INIT_STATIC_TABLE
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:270
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1658
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:166
VC1_NORM2_VLC_BITS
#define VC1_NORM2_VLC_BITS
Definition: vc1data.h:60
vc1_ttmb_codes
static const uint16_t vc1_ttmb_codes[3][16]
Definition: vc1_vlc_data.h:671
VC1Context::profile
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags.
Definition: vc1.h:216
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:395
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:76
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
ff_vc1_profiles
const AVProfile ff_vc1_profiles[]
Definition: profiles.c:147
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:1414
av_clip_uint16
#define av_clip_uint16
Definition: common.h:112
VC1Context::bi_type
int bi_type
Definition: vc1.h:384
VC1Context::mv_f_base
uint8_t * mv_f_base
Definition: vc1.h:348
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:647
VC1Context::fcm
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:308
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_vlc_init_tables
static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)
Definition: vlc.h:246
ff_vc1_ttmb_vlc
const VLCElem * ff_vc1_ttmb_vlc[3]
Definition: vc1data.c:109
vc1_2ref_mvdata_codes
static const uint32_t vc1_2ref_mvdata_codes[8][126]
Definition: vc1_vlc_data.h:242
mem.h
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:809
msmpeg4_vc1_data.h
vc1_vlc_data.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
MPVWorkPicture
Definition: mpegpicture.h:95
ff_vc1_norm2_vlc
VLCElem ff_vc1_norm2_vlc[1<< VC1_NORM2_VLC_BITS]
Definition: vc1data.c:106
ff_vc1_4mv_block_pattern_vlc
const VLCElem * ff_vc1_4mv_block_pattern_vlc[4]
Definition: vc1data.c:113
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:217
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:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
VC1Context::acpred_plane
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:321
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_PICTURE_TYPE_BI
@ AV_PICTURE_TYPE_BI
BI type.
Definition: avutil.h:285
VC1_2REF_MVDATA_VLC_BITS
#define VC1_2REF_MVDATA_VLC_BITS
Definition: vc1data.h:91
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
vc1_imode_codes
static const uint8_t vc1_imode_codes[7]
Definition: vc1_vlc_data.h:37
mpeg_er.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:632
imgutils.h
vc1_decode_init_alloc_tables
static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:359
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:455
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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 MSS2/VC1/WMV3 decoder.
Definition: vc1dec.c:813
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
vc1_decode_frame
static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:822
VC1Context::blk_mv_type
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:347
VC1_MV_DIFF_VLC_BITS
#define VC1_MV_DIFF_VLC_BITS
Definition: vc1data.h:67
AV_CODEC_ID_WMV3IMAGE
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:203
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
width
#define width
Definition: dsp.h:85
vc1_1ref_mvdata_codes
static const uint32_t vc1_1ref_mvdata_codes[4][72]
Definition: vc1_vlc_data.h:167
transpose
#define transpose(x)
VC1DSPContext::vc1_inv_trans_4x8
void(* vc1_inv_trans_4x8)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:39
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:217
VC1Context::blocks_off
int blocks_off
Definition: vc1.h:362
VC1_CODE_ENDOFSEQ
@ VC1_CODE_ENDOFSEQ
Definition: vc1_common.h:35
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
ff_wmv1_scantable
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4_vc1_data.c:220
VC1Context::rff
uint8_t rff
Definition: vc1.h:311
ff_mpv_decode_close
int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:163
ff_vc1_decode_init
av_cold int ff_vc1_decode_init(AVCodecContext *avctx)
Definition: vc1dec.c:454
vc1_mv_diff_bits
static const uint8_t vc1_mv_diff_bits[4][73]
Definition: vc1_vlc_data.h:806
Generated on Thu Feb 6 2025 19:22:18 for FFmpeg by   doxygen 1.8.17