FFmpeg  2.6.3
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
vc1dec.c
Go to the documentation of this file.
1 /*
2  * VC-1 and WMV3 decoder
3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
4  * Copyright (c) 2006-2007 Konstantin Shishkov
5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * VC-1 and WMV3 decoder
27  */
28 
29 #include "avcodec.h"
30 #include "blockdsp.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 #include "mpeg_er.h"
34 #include "mpegvideo.h"
35 #include "msmpeg4data.h"
36 #include "vc1.h"
37 #include "vc1data.h"
38 #include "vdpau_internal.h"
39 #include "libavutil/avassert.h"
40 
41 
42 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
43 
44 typedef struct SpriteData {
45  /**
46  * Transform coefficients for both sprites in 16.16 fixed point format,
47  * in the order they appear in the bitstream:
48  * x scale
49  * rotation 1 (unused)
50  * x offset
51  * rotation 2 (unused)
52  * y scale
53  * y offset
54  * alpha
55  */
56  int coefs[2][7];
57 
58  int effect_type, effect_flag;
59  int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
60  int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
61 } SpriteData;
62 
63 static inline int get_fp_val(GetBitContext* gb)
64 {
65  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
66 }
67 
68 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
69 {
70  c[1] = c[3] = 0;
71 
72  switch (get_bits(gb, 2)) {
73  case 0:
74  c[0] = 1 << 16;
75  c[2] = get_fp_val(gb);
76  c[4] = 1 << 16;
77  break;
78  case 1:
79  c[0] = c[4] = get_fp_val(gb);
80  c[2] = get_fp_val(gb);
81  break;
82  case 2:
83  c[0] = get_fp_val(gb);
84  c[2] = get_fp_val(gb);
85  c[4] = get_fp_val(gb);
86  break;
87  case 3:
88  c[0] = get_fp_val(gb);
89  c[1] = get_fp_val(gb);
90  c[2] = get_fp_val(gb);
91  c[3] = get_fp_val(gb);
92  c[4] = get_fp_val(gb);
93  break;
94  }
95  c[5] = get_fp_val(gb);
96  if (get_bits1(gb))
97  c[6] = get_fp_val(gb);
98  else
99  c[6] = 1 << 16;
100 }
101 
102 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
103 {
104  AVCodecContext *avctx = v->s.avctx;
105  int sprite, i;
106 
107  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
108  vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
109  if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
110  avpriv_request_sample(avctx, "Non-zero rotation coefficients");
111  av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
112  for (i = 0; i < 7; i++)
113  av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
114  sd->coefs[sprite][i] / (1<<16),
115  (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
116  av_log(avctx, AV_LOG_DEBUG, "\n");
117  }
118 
119  skip_bits(gb, 2);
120  if (sd->effect_type = get_bits_long(gb, 30)) {
121  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
122  case 7:
123  vc1_sprite_parse_transform(gb, sd->effect_params1);
124  break;
125  case 14:
126  vc1_sprite_parse_transform(gb, sd->effect_params1);
127  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
128  break;
129  default:
130  for (i = 0; i < sd->effect_pcount1; i++)
131  sd->effect_params1[i] = get_fp_val(gb);
132  }
133  if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
134  // effect 13 is simple alpha blending and matches the opacity above
135  av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
136  for (i = 0; i < sd->effect_pcount1; i++)
137  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
138  sd->effect_params1[i] / (1 << 16),
139  (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
140  av_log(avctx, AV_LOG_DEBUG, "\n");
141  }
142 
143  sd->effect_pcount2 = get_bits(gb, 16);
144  if (sd->effect_pcount2 > 10) {
145  av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
146  return AVERROR_INVALIDDATA;
147  } else if (sd->effect_pcount2) {
148  i = -1;
149  av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
150  while (++i < sd->effect_pcount2) {
151  sd->effect_params2[i] = get_fp_val(gb);
152  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
153  sd->effect_params2[i] / (1 << 16),
154  (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
155  }
156  av_log(avctx, AV_LOG_DEBUG, "\n");
157  }
158  }
159  if (sd->effect_flag = get_bits1(gb))
160  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
161 
162  if (get_bits_count(gb) >= gb->size_in_bits +
163  (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
164  av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
165  return AVERROR_INVALIDDATA;
166  }
167  if (get_bits_count(gb) < gb->size_in_bits - 8)
168  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
169 
170  return 0;
171 }
172 
173 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
174 {
175  int i, plane, row, sprite;
176  int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
177  uint8_t* src_h[2][2];
178  int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
179  int ysub[2];
180  MpegEncContext *s = &v->s;
181 
182  for (i = 0; i <= v->two_sprites; i++) {
183  xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
184  xadv[i] = sd->coefs[i][0];
185  if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
186  xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
187 
188  yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
189  yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
190  }
191  alpha = av_clip_uint16(sd->coefs[1][6]);
192 
193  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
194  int width = v->output_width>>!!plane;
195 
196  for (row = 0; row < v->output_height>>!!plane; row++) {
197  uint8_t *dst = v->sprite_output_frame->data[plane] +
198  v->sprite_output_frame->linesize[plane] * row;
199 
200  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
201  uint8_t *iplane = s->current_picture.f->data[plane];
202  int iline = s->current_picture.f->linesize[plane];
203  int ycoord = yoff[sprite] + yadv[sprite] * row;
204  int yline = ycoord >> 16;
205  int next_line;
206  ysub[sprite] = ycoord & 0xFFFF;
207  if (sprite) {
208  iplane = s->last_picture.f->data[plane];
209  iline = s->last_picture.f->linesize[plane];
210  }
211  next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
212  if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
213  src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
214  if (ysub[sprite])
215  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
216  } else {
217  if (sr_cache[sprite][0] != yline) {
218  if (sr_cache[sprite][1] == yline) {
219  FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
220  FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
221  } else {
222  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
223  sr_cache[sprite][0] = yline;
224  }
225  }
226  if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
227  v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
228  iplane + next_line, xoff[sprite],
229  xadv[sprite], width);
230  sr_cache[sprite][1] = yline + 1;
231  }
232  src_h[sprite][0] = v->sr_rows[sprite][0];
233  src_h[sprite][1] = v->sr_rows[sprite][1];
234  }
235  }
236 
237  if (!v->two_sprites) {
238  if (ysub[0]) {
239  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
240  } else {
241  memcpy(dst, src_h[0][0], width);
242  }
243  } else {
244  if (ysub[0] && ysub[1]) {
245  v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
246  src_h[1][0], src_h[1][1], ysub[1], alpha, width);
247  } else if (ysub[0]) {
248  v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
249  src_h[1][0], alpha, width);
250  } else if (ysub[1]) {
251  v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
252  src_h[0][0], (1<<16)-1-alpha, width);
253  } else {
254  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
255  }
256  }
257  }
258 
259  if (!plane) {
260  for (i = 0; i <= v->two_sprites; i++) {
261  xoff[i] >>= 1;
262  yoff[i] >>= 1;
263  }
264  }
265 
266  }
267 }
268 
269 
270 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
271 {
272  int ret;
273  MpegEncContext *s = &v->s;
274  AVCodecContext *avctx = s->avctx;
275  SpriteData sd;
276 
277  memset(&sd, 0, sizeof(sd));
278 
279  ret = vc1_parse_sprites(v, gb, &sd);
280  if (ret < 0)
281  return ret;
282 
283  if (!s->current_picture.f || !s->current_picture.f->data[0]) {
284  av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
285  return -1;
286  }
287 
288  if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
289  av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
290  v->two_sprites = 0;
291  }
292 
294  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
295  return ret;
296 
297  vc1_draw_sprites(v, &sd);
298 
299  return 0;
300 }
301 
302 static void vc1_sprite_flush(AVCodecContext *avctx)
303 {
304  VC1Context *v = avctx->priv_data;
305  MpegEncContext *s = &v->s;
306  AVFrame *f = s->current_picture.f;
307  int plane, i;
308 
309  /* Windows Media Image codecs have a convergence interval of two keyframes.
310  Since we can't enforce it, clear to black the missing sprite. This is
311  wrong but it looks better than doing nothing. */
312 
313  if (f && f->data[0])
314  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
315  for (i = 0; i < v->sprite_height>>!!plane; i++)
316  memset(f->data[plane] + i * f->linesize[plane],
317  plane ? 128 : 0, f->linesize[plane]);
318 }
319 
320 #endif
321 
323 {
324  MpegEncContext *s = &v->s;
325  int i;
326  int mb_height = FFALIGN(s->mb_height, 2);
327 
328  /* Allocate mb bitplanes */
329  v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
330  v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
331  v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
332  v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
333  v->acpred_plane = av_malloc (s->mb_stride * mb_height);
334  v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
335 
336  v->n_allocated_blks = s->mb_width + 2;
337  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
338  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
339  v->cbp = v->cbp_base + s->mb_stride;
340  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
341  v->ttblk = v->ttblk_base + s->mb_stride;
342  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
343  v->is_intra = v->is_intra_base + s->mb_stride;
344  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
345  v->luma_mv = v->luma_mv_base + s->mb_stride;
346 
347  /* allocate block type info in that way so it could be used with s->block_index[] */
348  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
349  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
350  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
351  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
352 
353  /* allocate memory to store block level MV info */
354  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
355  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
356  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
357  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
358  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
359  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
360  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
361  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362 
363  /* Init coded blocks info */
364  if (v->profile == PROFILE_ADVANCED) {
365 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
366 // return -1;
367 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
368 // return -1;
369  }
370 
371  ff_intrax8_common_init(&v->x8,s);
372 
374  for (i = 0; i < 4; i++)
375  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
376  return AVERROR(ENOMEM);
377  }
378 
379  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
380  !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
381  !v->mb_type_base) {
384  av_freep(&v->acpred_plane);
386  av_freep(&v->block);
387  av_freep(&v->cbp_base);
388  av_freep(&v->ttblk_base);
389  av_freep(&v->is_intra_base);
390  av_freep(&v->luma_mv_base);
391  av_freep(&v->mb_type_base);
392  return AVERROR(ENOMEM);
393  }
394 
395  return 0;
396 }
397 
399 {
400  int i;
401  for (i = 0; i < 64; i++) {
402 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
403  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
404  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
405  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
406  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
408  }
409  v->left_blk_sh = 0;
410  v->top_blk_sh = 3;
411 }
412 
413 /** Initialize a VC1/WMV3 decoder
414  * @todo TODO: Handle VC-1 IDUs (Transport level?)
415  * @todo TODO: Decypher remaining bits in extra_data
416  */
418 {
419  VC1Context *v = avctx->priv_data;
420  MpegEncContext *s = &v->s;
421  GetBitContext gb;
422  int ret;
423 
424  /* save the container output size for WMImage */
425  v->output_width = avctx->width;
426  v->output_height = avctx->height;
427 
428  if (!avctx->extradata_size || !avctx->extradata)
429  return -1;
430  if (!(avctx->flags & CODEC_FLAG_GRAY))
431  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
432  else
433  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
434  v->s.avctx = avctx;
435 
436  if ((ret = ff_vc1_init_common(v)) < 0)
437  return ret;
438  // ensure static VLC tables are initialized
439  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
440  return ret;
441  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
442  return ret;
443  // Hack to ensure the above functions will be called
444  // again once we know all necessary settings.
445  // That this is necessary might indicate a bug.
446  ff_vc1_decode_end(avctx);
447 
448  ff_blockdsp_init(&s->bdsp, avctx);
450  ff_qpeldsp_init(&s->qdsp);
451 
452  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
453  int count = 0;
454 
455  // looks like WMV3 has a sequence header stored in the extradata
456  // advanced sequence header may be before the first frame
457  // the last byte of the extradata is a version number, 1 for the
458  // samples we can decode
459 
460  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
461 
462  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
463  return ret;
464 
465  count = avctx->extradata_size*8 - get_bits_count(&gb);
466  if (count > 0) {
467  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
468  count, get_bits(&gb, count));
469  } else if (count < 0) {
470  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
471  }
472  } else { // VC1/WVC1/WVP2
473  const uint8_t *start = avctx->extradata;
474  uint8_t *end = avctx->extradata + avctx->extradata_size;
475  const uint8_t *next;
476  int size, buf2_size;
477  uint8_t *buf2 = NULL;
478  int seq_initialized = 0, ep_initialized = 0;
479 
480  if (avctx->extradata_size < 16) {
481  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
482  return -1;
483  }
484 
486  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
487  next = start;
488  for (; next < end; start = next) {
489  next = find_next_marker(start + 4, end);
490  size = next - start - 4;
491  if (size <= 0)
492  continue;
493  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
494  init_get_bits(&gb, buf2, buf2_size * 8);
495  switch (AV_RB32(start)) {
496  case VC1_CODE_SEQHDR:
497  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
498  av_free(buf2);
499  return ret;
500  }
501  seq_initialized = 1;
502  break;
503  case VC1_CODE_ENTRYPOINT:
504  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
505  av_free(buf2);
506  return ret;
507  }
508  ep_initialized = 1;
509  break;
510  }
511  }
512  av_free(buf2);
513  if (!seq_initialized || !ep_initialized) {
514  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
515  return -1;
516  }
517  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
518  }
519 
521  if (!v->sprite_output_frame)
522  return AVERROR(ENOMEM);
523 
524  avctx->profile = v->profile;
525  if (v->profile == PROFILE_ADVANCED)
526  avctx->level = v->level;
527 
528  avctx->has_b_frames = !!avctx->max_b_frames;
529 
530  if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
531  avctx->color_primaries = v->color_prim;
532  if (v->transfer_char == 1 || v->transfer_char == 7)
533  avctx->color_trc = v->transfer_char;
534  if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
535  avctx->colorspace = v->matrix_coef;
536 
537  s->mb_width = (avctx->coded_width + 15) >> 4;
538  s->mb_height = (avctx->coded_height + 15) >> 4;
539 
540  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
542  } else {
543  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
544  v->left_blk_sh = 3;
545  v->top_blk_sh = 0;
546  }
547 
548  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
549  v->sprite_width = avctx->coded_width;
550  v->sprite_height = avctx->coded_height;
551 
552  avctx->coded_width = avctx->width = v->output_width;
553  avctx->coded_height = avctx->height = v->output_height;
554 
555  // prevent 16.16 overflows
556  if (v->sprite_width > 1 << 14 ||
557  v->sprite_height > 1 << 14 ||
558  v->output_width > 1 << 14 ||
559  v->output_height > 1 << 14) return -1;
560 
561  if ((v->sprite_width&1) || (v->sprite_height&1)) {
562  avpriv_request_sample(avctx, "odd sprites support");
563  return AVERROR_PATCHWELCOME;
564  }
565  }
566  return 0;
567 }
568 
569 /** Close a VC1/WMV3 decoder
570  * @warning Initial try at using MpegEncContext stuff
571  */
573 {
574  VC1Context *v = avctx->priv_data;
575  int i;
576 
578 
579  for (i = 0; i < 4; i++)
580  av_freep(&v->sr_rows[i >> 1][i & 1]);
581  av_freep(&v->hrd_rate);
582  av_freep(&v->hrd_buffer);
583  ff_mpv_common_end(&v->s);
587  av_freep(&v->fieldtx_plane);
588  av_freep(&v->acpred_plane);
590  av_freep(&v->mb_type_base);
592  av_freep(&v->mv_f_base);
594  av_freep(&v->block);
595  av_freep(&v->cbp_base);
596  av_freep(&v->ttblk_base);
597  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
598  av_freep(&v->luma_mv_base);
600  return 0;
601 }
602 
603 
604 /** Decode a VC1/WMV3 frame
605  * @todo TODO: Handle VC-1 IDUs (Transport level?)
606  */
607 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
608  int *got_frame, AVPacket *avpkt)
609 {
610  const uint8_t *buf = avpkt->data;
611  int buf_size = avpkt->size, n_slices = 0, i, ret;
612  VC1Context *v = avctx->priv_data;
613  MpegEncContext *s = &v->s;
614  AVFrame *pict = data;
615  uint8_t *buf2 = NULL;
616  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
617  int mb_height, n_slices1=-1;
618  struct {
619  uint8_t *buf;
620  GetBitContext gb;
621  int mby_start;
622  } *slices = NULL, *tmp;
623 
624  v->second_field = 0;
625 
626  if(s->flags & CODEC_FLAG_LOW_DELAY)
627  s->low_delay = 1;
628 
629  /* no supplementary picture */
630  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
631  /* special case for last picture */
632  if (s->low_delay == 0 && s->next_picture_ptr) {
633  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
634  return ret;
635  s->next_picture_ptr = NULL;
636 
637  *got_frame = 1;
638  }
639 
640  return buf_size;
641  }
642 
644  if (v->profile < PROFILE_ADVANCED)
646  else
647  avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
648  }
649 
650  //for advanced profile we may need to parse and unescape data
651  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
652  int buf_size2 = 0;
653  buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
654  if (!buf2)
655  return AVERROR(ENOMEM);
656 
657  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
658  const uint8_t *start, *end, *next;
659  int size;
660 
661  next = buf;
662  for (start = buf, end = buf + buf_size; next < end; start = next) {
663  next = find_next_marker(start + 4, end);
664  size = next - start - 4;
665  if (size <= 0) continue;
666  switch (AV_RB32(start)) {
667  case VC1_CODE_FRAME:
668  if (avctx->hwaccel ||
670  buf_start = start;
671  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
672  break;
673  case VC1_CODE_FIELD: {
674  int buf_size3;
675  if (avctx->hwaccel ||
677  buf_start_second_field = start;
678  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
679  if (!tmp)
680  goto err;
681  slices = tmp;
682  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
683  if (!slices[n_slices].buf)
684  goto err;
685  buf_size3 = vc1_unescape_buffer(start + 4, size,
686  slices[n_slices].buf);
687  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
688  buf_size3 << 3);
689  /* assuming that the field marker is at the exact middle,
690  hope it's correct */
691  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
692  n_slices1 = n_slices - 1; // index of the last slice of the first field
693  n_slices++;
694  break;
695  }
696  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
697  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
698  init_get_bits(&s->gb, buf2, buf_size2 * 8);
699  ff_vc1_decode_entry_point(avctx, v, &s->gb);
700  break;
701  case VC1_CODE_SLICE: {
702  int buf_size3;
703  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
704  if (!tmp)
705  goto err;
706  slices = tmp;
707  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
708  if (!slices[n_slices].buf)
709  goto err;
710  buf_size3 = vc1_unescape_buffer(start + 4, size,
711  slices[n_slices].buf);
712  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
713  buf_size3 << 3);
714  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
715  n_slices++;
716  break;
717  }
718  }
719  }
720  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
721  const uint8_t *divider;
722  int buf_size3;
723 
724  divider = find_next_marker(buf, buf + buf_size);
725  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
726  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
727  goto err;
728  } else { // found field marker, unescape second field
729  if (avctx->hwaccel ||
731  buf_start_second_field = divider;
732  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
733  if (!tmp)
734  goto err;
735  slices = tmp;
736  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
737  if (!slices[n_slices].buf)
738  goto err;
739  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
740  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
741  buf_size3 << 3);
742  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
743  n_slices1 = n_slices - 1;
744  n_slices++;
745  }
746  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
747  } else {
748  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
749  }
750  init_get_bits(&s->gb, buf2, buf_size2*8);
751  } else
752  init_get_bits(&s->gb, buf, buf_size*8);
753 
754  if (v->res_sprite) {
755  v->new_sprite = !get_bits1(&s->gb);
756  v->two_sprites = get_bits1(&s->gb);
757  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
758  we're using the sprite compositor. These are intentionally kept separate
759  so you can get the raw sprites by using the wmv3 decoder for WMVP or
760  the vc1 one for WVP2 */
761  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
762  if (v->new_sprite) {
763  // switch AVCodecContext parameters to those of the sprites
764  avctx->width = avctx->coded_width = v->sprite_width;
765  avctx->height = avctx->coded_height = v->sprite_height;
766  } else {
767  goto image;
768  }
769  }
770  }
771 
772  if (s->context_initialized &&
773  (s->width != avctx->coded_width ||
774  s->height != avctx->coded_height)) {
775  ff_vc1_decode_end(avctx);
776  }
777 
778  if (!s->context_initialized) {
779  if (ff_msmpeg4_decode_init(avctx) < 0)
780  goto err;
781  if (ff_vc1_decode_init_alloc_tables(v) < 0) {
783  goto err;
784  }
785 
786  s->low_delay = !avctx->has_b_frames || v->res_sprite;
787 
788  if (v->profile == PROFILE_ADVANCED) {
789  if(avctx->coded_width<=1 || avctx->coded_height<=1)
790  goto err;
791  s->h_edge_pos = avctx->coded_width;
792  s->v_edge_pos = avctx->coded_height;
793  }
794  }
795 
796  // do parse frame header
797  v->pic_header_flag = 0;
798  v->first_pic_header_flag = 1;
799  if (v->profile < PROFILE_ADVANCED) {
800  if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
801  goto err;
802  }
803  } else {
804  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
805  goto err;
806  }
807  }
808  v->first_pic_header_flag = 0;
809 
810  if (avctx->debug & FF_DEBUG_PICT_INFO)
811  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
812 
813  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
814  && s->pict_type != AV_PICTURE_TYPE_I) {
815  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
816  goto err;
817  }
818 
819  if ((s->mb_height >> v->field_mode) == 0) {
820  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
821  goto err;
822  }
823 
824  // for skipping the frame
827 
828  /* skip B-frames if we don't have reference frames */
829  if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
830  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
831  goto end;
832  }
833  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
835  avctx->skip_frame >= AVDISCARD_ALL) {
836  goto end;
837  }
838 
839  if (s->next_p_frame_damaged) {
840  if (s->pict_type == AV_PICTURE_TYPE_B)
841  goto end;
842  else
843  s->next_p_frame_damaged = 0;
844  }
845 
846  if (ff_mpv_frame_start(s, avctx) < 0) {
847  goto err;
848  }
849 
853 
854  // process pulldown flags
856  // Pulldown flags are only valid when 'broadcast' has been set.
857  // So ticks_per_frame will be 2
858  if (v->rff) {
859  // repeat field
861  } else if (v->rptfrm) {
862  // repeat frames
863  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
864  }
865 
868 
871  if (v->field_mode && buf_start_second_field) {
872  ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
873  ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
874  } else {
875  ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
876  }
877  } else if (avctx->hwaccel) {
878  if (v->field_mode && buf_start_second_field) {
879  // decode first field
881  if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
882  goto err;
883  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
884  goto err;
885  if (avctx->hwaccel->end_frame(avctx) < 0)
886  goto err;
887 
888  // decode second field
889  s->gb = slices[n_slices1 + 1].gb;
891  v->second_field = 1;
892  v->pic_header_flag = 0;
893  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
894  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
895  goto err;
896  }
898 
899  if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
900  goto err;
901  if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
902  goto err;
903  if (avctx->hwaccel->end_frame(avctx) < 0)
904  goto err;
905  } else {
907  if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
908  goto err;
909  if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
910  goto err;
911  if (avctx->hwaccel->end_frame(avctx) < 0)
912  goto err;
913  }
914  } else {
915  int header_ret = 0;
916 
918 
919  v->bits = buf_size * 8;
920  v->end_mb_x = s->mb_width;
921  if (v->field_mode) {
922  s->current_picture.f->linesize[0] <<= 1;
923  s->current_picture.f->linesize[1] <<= 1;
924  s->current_picture.f->linesize[2] <<= 1;
925  s->linesize <<= 1;
926  s->uvlinesize <<= 1;
927  }
928  mb_height = s->mb_height >> v->field_mode;
929 
930  av_assert0 (mb_height > 0);
931 
932  for (i = 0; i <= n_slices; i++) {
933  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
934  if (v->field_mode <= 0) {
935  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
936  "picture boundary (%d >= %d)\n", i,
937  slices[i - 1].mby_start, mb_height);
938  continue;
939  }
940  v->second_field = 1;
941  av_assert0((s->mb_height & 1) == 0);
942  v->blocks_off = s->b8_stride * (s->mb_height&~1);
943  v->mb_off = s->mb_stride * s->mb_height >> 1;
944  } else {
945  v->second_field = 0;
946  v->blocks_off = 0;
947  v->mb_off = 0;
948  }
949  if (i) {
950  v->pic_header_flag = 0;
951  if (v->field_mode && i == n_slices1 + 2) {
952  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
953  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
954  if (avctx->err_recognition & AV_EF_EXPLODE)
955  goto err;
956  continue;
957  }
958  } else if (get_bits1(&s->gb)) {
959  v->pic_header_flag = 1;
960  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
961  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
962  if (avctx->err_recognition & AV_EF_EXPLODE)
963  goto err;
964  continue;
965  }
966  }
967  }
968  if (header_ret < 0)
969  continue;
970  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
971  if (!v->field_mode || v->second_field)
972  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
973  else {
974  if (i >= n_slices) {
975  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
976  continue;
977  }
978  s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
979  }
980  if (s->end_mb_y <= s->start_mb_y) {
981  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
982  continue;
983  }
984  if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
985  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
986  continue;
987  }
989  if (i != n_slices)
990  s->gb = slices[i].gb;
991  }
992  if (v->field_mode) {
993  v->second_field = 0;
994  s->current_picture.f->linesize[0] >>= 1;
995  s->current_picture.f->linesize[1] >>= 1;
996  s->current_picture.f->linesize[2] >>= 1;
997  s->linesize >>= 1;
998  s->uvlinesize >>= 1;
1000  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1001  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1002  }
1003  }
1004  av_dlog(s->avctx, "Consumed %i/%i bits\n",
1005  get_bits_count(&s->gb), s->gb.size_in_bits);
1006 // if (get_bits_count(&s->gb) > buf_size * 8)
1007 // return -1;
1009  goto err;
1010  if (!v->field_mode)
1011  ff_er_frame_end(&s->er);
1012  }
1013 
1014  ff_mpv_frame_end(s);
1015 
1016  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1017 image:
1018  avctx->width = avctx->coded_width = v->output_width;
1019  avctx->height = avctx->coded_height = v->output_height;
1020  if (avctx->skip_frame >= AVDISCARD_NONREF)
1021  goto end;
1022 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1023  if (vc1_decode_sprites(v, &s->gb))
1024  goto err;
1025 #endif
1026  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1027  goto err;
1028  *got_frame = 1;
1029  } else {
1030  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1031  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1032  goto err;
1034  *got_frame = 1;
1035  } else if (s->last_picture_ptr) {
1036  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1037  goto err;
1039  *got_frame = 1;
1040  }
1041  }
1042 
1043 end:
1044  av_free(buf2);
1045  for (i = 0; i < n_slices; i++)
1046  av_free(slices[i].buf);
1047  av_free(slices);
1048  return buf_size;
1049 
1050 err:
1051  av_free(buf2);
1052  for (i = 0; i < n_slices; i++)
1053  av_free(slices[i].buf);
1054  av_free(slices);
1055  return -1;
1056 }
1057 
1058 
1059 static const AVProfile profiles[] = {
1060  { FF_PROFILE_VC1_SIMPLE, "Simple" },
1061  { FF_PROFILE_VC1_MAIN, "Main" },
1062  { FF_PROFILE_VC1_COMPLEX, "Complex" },
1063  { FF_PROFILE_VC1_ADVANCED, "Advanced" },
1064  { FF_PROFILE_UNKNOWN },
1065 };
1066 
1068 #if CONFIG_VC1_DXVA2_HWACCEL
1070 #endif
1071 #if CONFIG_VC1_VAAPI_HWACCEL
1073 #endif
1074 #if CONFIG_VC1_VDPAU_HWACCEL
1076 #endif
1079 };
1080 
1082  .name = "vc1",
1083  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1084  .type = AVMEDIA_TYPE_VIDEO,
1085  .id = AV_CODEC_ID_VC1,
1086  .priv_data_size = sizeof(VC1Context),
1087  .init = vc1_decode_init,
1088  .close = ff_vc1_decode_end,
1090  .flush = ff_mpeg_flush,
1091  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1092  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1093  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1094 };
1095 
1096 #if CONFIG_WMV3_DECODER
1097 AVCodec ff_wmv3_decoder = {
1098  .name = "wmv3",
1099  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1100  .type = AVMEDIA_TYPE_VIDEO,
1101  .id = AV_CODEC_ID_WMV3,
1102  .priv_data_size = sizeof(VC1Context),
1103  .init = vc1_decode_init,
1104  .close = ff_vc1_decode_end,
1106  .flush = ff_mpeg_flush,
1107  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1108  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1109  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1110 };
1111 #endif
1112 
1113 #if CONFIG_WMV3_VDPAU_DECODER
1114 AVCodec ff_wmv3_vdpau_decoder = {
1115  .name = "wmv3_vdpau",
1116  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1117  .type = AVMEDIA_TYPE_VIDEO,
1118  .id = AV_CODEC_ID_WMV3,
1119  .priv_data_size = sizeof(VC1Context),
1120  .init = vc1_decode_init,
1121  .close = ff_vc1_decode_end,
1124  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1125  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1126 };
1127 #endif
1128 
1129 #if CONFIG_VC1_VDPAU_DECODER
1130 AVCodec ff_vc1_vdpau_decoder = {
1131  .name = "vc1_vdpau",
1132  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1133  .type = AVMEDIA_TYPE_VIDEO,
1134  .id = AV_CODEC_ID_VC1,
1135  .priv_data_size = sizeof(VC1Context),
1136  .init = vc1_decode_init,
1137  .close = ff_vc1_decode_end,
1140  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1141  .profiles = NULL_IF_CONFIG_SMALL(profiles)
1142 };
1143 #endif
1144 
1145 #if CONFIG_WMV3IMAGE_DECODER
1146 AVCodec ff_wmv3image_decoder = {
1147  .name = "wmv3image",
1148  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1149  .type = AVMEDIA_TYPE_VIDEO,
1150  .id = AV_CODEC_ID_WMV3IMAGE,
1151  .priv_data_size = sizeof(VC1Context),
1152  .init = vc1_decode_init,
1153  .close = ff_vc1_decode_end,
1155  .capabilities = CODEC_CAP_DR1,
1156  .flush = vc1_sprite_flush,
1157  .pix_fmts = (const enum AVPixelFormat[]) {
1160  },
1161 };
1162 #endif
1163 
1164 #if CONFIG_VC1IMAGE_DECODER
1165 AVCodec ff_vc1image_decoder = {
1166  .name = "vc1image",
1167  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1168  .type = AVMEDIA_TYPE_VIDEO,
1169  .id = AV_CODEC_ID_VC1IMAGE,
1170  .priv_data_size = sizeof(VC1Context),
1171  .init = vc1_decode_init,
1172  .close = ff_vc1_decode_end,
1174  .capabilities = CODEC_CAP_DR1,
1175  .flush = vc1_sprite_flush,
1176  .pix_fmts = (const enum AVPixelFormat[]) {
1179  },
1180 };
1181 #endif
int color_prim
8bits, chroma coordinates of the color primaries
Definition: vc1.h:206
in the bitstream is reported as 00b
Definition: vc1.h:149
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1248
discard all frames except keyframes
Definition: avcodec.h:666
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:3338
BI type.
Definition: avutil.h:273
float v
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:74
int p_frame_skipped
Definition: vc1.h:380
const char * s
Definition: avisynth_c.h:669
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
The VC1 Context.
Definition: vc1.h:173
This structure describes decoded (raw) audio or video data.
Definition: frame.h:163
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:287
uint8_t * mv_f_base
Definition: vc1.h:350
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1422
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:181
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:288
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:1501
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:266
void ff_er_frame_end(ERContext *s)
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:71
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:354
int size
Definition: avcodec.h:1161
int transfer_char
8bits, Opto-electronic transfer characteristics
Definition: vc1.h:207
HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the b...
Definition: pixfmt.h:131
int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:286
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegvideo.h:139
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1442
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition: vc1.h:239
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
mpegvideo header.
IntraX8Context x8
Definition: vc1.h:175
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
uint8_t * mb_type_base
Definition: vc1.h:264
discard all
Definition: avcodec.h:667
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition: vc1.h:350
int sprite_height
Definition: vc1.h:376
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:393
int profile
profile
Definition: avcodec.h:2833
QpelDSPContext qdsp
Definition: mpegvideo.h:371
AVCodec.
Definition: avcodec.h:3173
#define FFALIGN(x, a)
Definition: common.h:71
uint8_t rff
Definition: vc1.h:311
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2939
int bits
Definition: vc1.h:179
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2642
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:321
VC-1 tables.
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static const AVProfile profiles[]
Definition: vc1dec.c:1059
int matrix_coef
8bits, Color primaries->YCbCr transform matrix
Definition: vc1.h:208
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
int first_pic_header_flag
Definition: vc1.h:368
uint16_t * hrd_rate
Definition: vc1.h:326
av_cold int ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition: vc1.c:1576
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:73
#define AV_RB32
Definition: intreadwrite.h:130
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:201
#define FF_PROFILE_VC1_ADVANCED
Definition: avcodec.h:2881
int second_field
Definition: vc1.h:354
#define CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
Definition: avcodec.h:832
int n_allocated_blks
Definition: vc1.h:385
qpel_mc_func(* qpel_put)[16]
Definition: mpegvideo.h:199
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:278
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2834
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1353
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:314
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:787
int16_t((* luma_mv)[2]
Definition: vc1.h:388
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags...
Definition: vc1.h:218
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:34
MSMPEG4 data tables.
uint8_t * data
Definition: avcodec.h:1160
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
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:84
bitstream reader API header.
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:288
WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstrea...
Definition: pixfmt.h:113
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:359
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:263
ptrdiff_t size
Definition: opengl_enc.c:101
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition: vc1.c:277
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:323
#define av_log(a,...)
#define transpose(x)
int16_t(* block)[6][64]
Definition: vc1.h:384
static double alpha(void *priv, double x, double y)
Definition: vf_geq.c:98
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:175
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1531
#define FF_PROFILE_VC1_COMPLEX
Definition: avcodec.h:2880
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2621
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:822
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:180
ERContext er
Definition: mpegvideo.h:678
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition: vc1dec.c:417
int capabilities
Codec capabilities.
Definition: avcodec.h:3192
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:196
uint8_t * mv_f_next_base
Definition: vc1.h:351
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1333
simple assert() macros that are a bit more flexible than ISO C assert().
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2924
#define PICT_TOP_FIELD
Definition: mpegutils.h:33
const char * name
Name of the codec implementation.
Definition: avcodec.h:3180
#define IS_MARKER(state, i, buf, buf_size)
Definition: dca_parser.c:38
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:537
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:73
GetBitContext gb
Definition: mpegvideo.h:577
GLsizei count
Definition: opengl_enc.c:109
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1534
#define FFMAX(a, b)
Definition: common.h:64
Libavcodec external API header.
#define FF_PROFILE_VC1_MAIN
Definition: avcodec.h:2879
#define CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:755
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:349
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:3364
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:845
const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]
Definition: vc1data.c:1047
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:628
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1825
AVCodec ff_vc1_decoder
Definition: vc1dec.c:1081
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3194
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:234
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a VC1/WMV3 decoder.
Definition: vc1dec.c:572
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2610
#define FFMIN(a, b)
Definition: common.h:66
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition: vc1dec.c:398
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed b frames
Definition: mpegvideo.h:493
uint8_t * blk_mv_type_base
Definition: vc1.h:349
av_cold void ff_intrax8_common_init(IntraX8Context *w, MpegEncContext *const s)
Initialize IntraX8 frame decoder.
Definition: intrax8.c:692
int field_mode
1 for interlaced field pictures
Definition: vc1.h:352
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition: intrax8.c:714
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1412
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:318
int mb_off
Definition: vc1.h:364
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
int size_in_bits
Definition: get_bits.h:57
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1937
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
Definition: vc1dec.c:322
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition: vc1.c:628
int level
level
Definition: avcodec.h:2917
MotionEstContext me
Definition: mpegvideo.h:416
uint32_t * cbp
Definition: vc1.h:386
int left_blk_sh
Definition: vc1.h:240
int16_t(* luma_mv_base)[2]
Definition: vc1.h:388
uint8_t * fieldtx_plane
Definition: vc1.h:346
static void flush(AVCodecContext *avctx)
Definition: aacdec.c:502
int * ttblk_base
Definition: vc1.h:259
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:284
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition: vc1.h:377
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: utils.c:1193
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_LOG_INFO
Standard information.
Definition: log.h:186
int res_sprite
Simple/Main Profile sequence header.
Definition: vc1.h:183
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:240
static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
Definition: vc1_common.h:70
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:268
enum AVCodecID codec_id
Definition: avcodec.h:1256
BlockDSPContext bdsp
Definition: mpegvideo.h:362
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:191
int debug
debug
Definition: avcodec.h:2563
uint32_t * cbp_base
Definition: vc1.h:386
main external API structure.
Definition: avcodec.h:1239
uint8_t * is_intra
Definition: vc1.h:387
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:231
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1030
void * buf
Definition: avisynth_c.h:595
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:2527
void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)
Definition: vc1dsp.h:70
int extradata_size
Definition: avcodec.h:1354
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
int sprite_width
Definition: vc1.h:376
uint8_t * is_intra_base
Definition: vc1.h:387
int coded_height
Definition: avcodec.h:1422
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1951
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1944
struct AVFrame * f
Definition: mpegvideo.h:103
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:216
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:410
int context_initialized
Definition: mpegvideo.h:258
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:269
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1769
#define CONFIG_VC1_VDPAU_DECODER
Definition: config.h:754
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:337
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:287
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:142
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:348
static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition: vc1dec.c:607
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:286
int blocks_off
Definition: vc1.h:364
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:377
#define FF_PROFILE_VC1_SIMPLE
Definition: avcodec.h:2878
uint8_t tff
Definition: vc1.h:311
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:174
qpel_mc_func(* qpel_avg)[16]
Definition: mpegvideo.h:200
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2564
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:265
MpegEncContext s
Definition: vc1.h:174
MpegEncContext.
Definition: mpegvideo.h:212
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:317
struct AVCodecContext * avctx
Definition: mpegvideo.h:229
VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstrea...
Definition: pixfmt.h:114
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:520
discard all non reference
Definition: avcodec.h:663
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:68
Y , 8bpp.
Definition: pixfmt.h:76
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:264
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:736
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition: vc1dec.c:1067
int output_width
Definition: vc1.h:376
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:308
static double c[64]
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:296
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:316
Bi-dir predicted.
Definition: avutil.h:269
AVProfile.
Definition: avcodec.h:3161
int res_fasttx
reserved, always 1
Definition: vc1.h:187
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:206
int pic_header_flag
Definition: vc1.h:369
int * ttblk
Transform type at the block level.
Definition: vc1.h:259
void * priv_data
Definition: avcodec.h:1281
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition: vc1.c:510
#define PICT_FRAME
Definition: mpegutils.h:35
int picture_structure
Definition: mpegvideo.h:589
#define av_free(p)
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:364
AVFrame * sprite_output_frame
Definition: vc1.h:375
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1996
uint8_t zzi_8x8[64]
Definition: vc1.h:348
void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)
Definition: vc1dsp.h:69
uint8_t rptfrm
Definition: vc1.h:311
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:229
H264ChromaContext h264chroma
Definition: vc1.h:176
int level
Advanced Profile.
Definition: vc1.h:197
int flags
AVCodecContext.flags (HQ, MV4, ...)
Definition: mpegvideo.h:246
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:595
int new_sprite
Frame decoding info for sprite modes.
Definition: vc1.h:373
uint8_t * mv_f_next[2]
Definition: vc1.h:351
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:783
#define FFSWAP(type, a, b)
Definition: common.h:69
int two_sprites
Definition: vc1.h:374
uint8_t * mb_type[3]
Definition: vc1.h:264
uint16_t * hrd_buffer
Definition: vc1.h:326
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3352
void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf, int buf_size)
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3363
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
This structure stores compressed data.
Definition: avcodec.h:1137
static av_always_inline const uint8_t * find_next_marker(const uint8_t *src, const uint8_t *end)
Find VC-1 marker in buffer.
Definition: vc1_common.h:59
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:250
VC1DSPContext vc1dsp
Definition: vc1.h:177
int output_height
Definition: vc1.h:376
void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)
Definition: vc1dsp.h:68
static int width