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