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