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