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
7 * This file is part of FFmpeg.
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.
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.
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
26 * VC-1 and WMV3 decoder
34 #include "mpegvideo.h"
36 #include "msmpeg4data.h"
40 #include "vdpau_compat.h"
41 #include "libavutil/avassert.h"
44 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
46 typedef struct SpriteData {
48 * Transform coefficients for both sprites in 16.16 fixed point format,
49 * in the order they appear in the bitstream:
60 int effect_type, effect_flag;
61 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
62 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
65 static inline int get_fp_val(GetBitContext* gb)
67 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
70 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
74 switch (get_bits(gb, 2)) {
77 c[2] = get_fp_val(gb);
81 c[0] = c[4] = get_fp_val(gb);
82 c[2] = get_fp_val(gb);
85 c[0] = get_fp_val(gb);
86 c[2] = get_fp_val(gb);
87 c[4] = get_fp_val(gb);
90 c[0] = get_fp_val(gb);
91 c[1] = get_fp_val(gb);
92 c[2] = get_fp_val(gb);
93 c[3] = get_fp_val(gb);
94 c[4] = get_fp_val(gb);
97 c[5] = get_fp_val(gb);
99 c[6] = get_fp_val(gb);
104 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
106 AVCodecContext *avctx = v->s.avctx;
109 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
110 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
111 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
112 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
113 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
114 for (i = 0; i < 7; i++)
115 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
116 sd->coefs[sprite][i] / (1<<16),
117 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
118 av_log(avctx, AV_LOG_DEBUG, "\n");
122 if (sd->effect_type = get_bits_long(gb, 30)) {
123 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
125 vc1_sprite_parse_transform(gb, sd->effect_params1);
128 vc1_sprite_parse_transform(gb, sd->effect_params1);
129 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
132 for (i = 0; i < sd->effect_pcount1; i++)
133 sd->effect_params1[i] = get_fp_val(gb);
135 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
136 // effect 13 is simple alpha blending and matches the opacity above
137 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
138 for (i = 0; i < sd->effect_pcount1; i++)
139 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
140 sd->effect_params1[i] / (1 << 16),
141 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
142 av_log(avctx, AV_LOG_DEBUG, "\n");
145 sd->effect_pcount2 = get_bits(gb, 16);
146 if (sd->effect_pcount2 > 10) {
147 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
148 return AVERROR_INVALIDDATA;
149 } else if (sd->effect_pcount2) {
151 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
152 while (++i < sd->effect_pcount2) {
153 sd->effect_params2[i] = get_fp_val(gb);
154 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
155 sd->effect_params2[i] / (1 << 16),
156 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
158 av_log(avctx, AV_LOG_DEBUG, "\n");
161 if (sd->effect_flag = get_bits1(gb))
162 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
164 if (get_bits_count(gb) >= gb->size_in_bits +
165 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
166 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
167 return AVERROR_INVALIDDATA;
169 if (get_bits_count(gb) < gb->size_in_bits - 8)
170 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
175 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
177 int i, plane, row, sprite;
178 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
179 uint8_t* src_h[2][2];
180 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
182 MpegEncContext *s = &v->s;
184 for (i = 0; i <= v->two_sprites; i++) {
185 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
186 xadv[i] = sd->coefs[i][0];
187 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
188 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
190 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
191 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
193 alpha = av_clip_uint16(sd->coefs[1][6]);
195 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
196 int width = v->output_width>>!!plane;
198 for (row = 0; row < v->output_height>>!!plane; row++) {
199 uint8_t *dst = v->sprite_output_frame->data[plane] +
200 v->sprite_output_frame->linesize[plane] * row;
202 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
203 uint8_t *iplane = s->current_picture.f->data[plane];
204 int iline = s->current_picture.f->linesize[plane];
205 int ycoord = yoff[sprite] + yadv[sprite] * row;
206 int yline = ycoord >> 16;
208 ysub[sprite] = ycoord & 0xFFFF;
210 iplane = s->last_picture.f->data[plane];
211 iline = s->last_picture.f->linesize[plane];
213 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
214 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
215 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
217 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
219 if (sr_cache[sprite][0] != yline) {
220 if (sr_cache[sprite][1] == yline) {
221 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
222 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
224 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
225 sr_cache[sprite][0] = yline;
228 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
229 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
230 iplane + next_line, xoff[sprite],
231 xadv[sprite], width);
232 sr_cache[sprite][1] = yline + 1;
234 src_h[sprite][0] = v->sr_rows[sprite][0];
235 src_h[sprite][1] = v->sr_rows[sprite][1];
239 if (!v->two_sprites) {
241 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
243 memcpy(dst, src_h[0][0], width);
246 if (ysub[0] && ysub[1]) {
247 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
248 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
249 } else if (ysub[0]) {
250 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
251 src_h[1][0], alpha, width);
252 } else if (ysub[1]) {
253 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
254 src_h[0][0], (1<<16)-1-alpha, width);
256 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
262 for (i = 0; i <= v->two_sprites; i++) {
272 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
275 MpegEncContext *s = &v->s;
276 AVCodecContext *avctx = s->avctx;
279 memset(&sd, 0, sizeof(sd));
281 ret = vc1_parse_sprites(v, gb, &sd);
285 if (!s->current_picture.f || !s->current_picture.f->data[0]) {
286 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
287 return AVERROR_UNKNOWN;
290 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
291 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
295 av_frame_unref(v->sprite_output_frame);
296 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
299 vc1_draw_sprites(v, &sd);
304 static void vc1_sprite_flush(AVCodecContext *avctx)
306 VC1Context *v = avctx->priv_data;
307 MpegEncContext *s = &v->s;
308 AVFrame *f = s->current_picture.f;
311 /* Windows Media Image codecs have a convergence interval of two keyframes.
312 Since we can't enforce it, clear to black the missing sprite. This is
313 wrong but it looks better than doing nothing. */
316 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
317 for (i = 0; i < v->sprite_height>>!!plane; i++)
318 memset(f->data[plane] + i * f->linesize[plane],
319 plane ? 128 : 0, f->linesize[plane]);
324 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
326 MpegEncContext *s = &v->s;
328 int mb_height = FFALIGN(s->mb_height, 2);
330 /* Allocate mb bitplanes */
331 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
332 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
333 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
334 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
335 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
336 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
338 v->n_allocated_blks = s->mb_width + 2;
339 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
340 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
341 v->cbp = v->cbp_base + s->mb_stride;
342 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
343 v->ttblk = v->ttblk_base + s->mb_stride;
344 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
345 v->is_intra = v->is_intra_base + s->mb_stride;
346 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
347 v->luma_mv = v->luma_mv_base + s->mb_stride;
349 /* allocate block type info in that way so it could be used with s->block_index[] */
350 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
351 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
352 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
353 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
355 /* allocate memory to store block level MV info */
356 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
357 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
358 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
359 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
360 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
361 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
362 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
363 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
365 /* Init coded blocks info */
366 if (v->profile == PROFILE_ADVANCED) {
367 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
369 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
373 ff_intrax8_common_init(&v->x8,s);
375 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
376 for (i = 0; i < 4; i++)
377 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
378 return AVERROR(ENOMEM);
381 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
382 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
384 av_freep(&v->mv_type_mb_plane);
385 av_freep(&v->direct_mb_plane);
386 av_freep(&v->acpred_plane);
387 av_freep(&v->over_flags_plane);
389 av_freep(&v->cbp_base);
390 av_freep(&v->ttblk_base);
391 av_freep(&v->is_intra_base);
392 av_freep(&v->luma_mv_base);
393 av_freep(&v->mb_type_base);
394 return AVERROR(ENOMEM);
400 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
403 for (i = 0; i < 64; i++) {
404 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
405 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
406 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
407 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
408 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
409 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
415 /** Initialize a VC1/WMV3 decoder
416 * @todo TODO: Handle VC-1 IDUs (Transport level?)
417 * @todo TODO: Decypher remaining bits in extra_data
419 static av_cold int vc1_decode_init(AVCodecContext *avctx)
421 VC1Context *v = avctx->priv_data;
422 MpegEncContext *s = &v->s;
426 /* save the container output size for WMImage */
427 v->output_width = avctx->width;
428 v->output_height = avctx->height;
430 if (!avctx->extradata_size || !avctx->extradata)
434 if ((ret = ff_vc1_init_common(v)) < 0)
437 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
440 // looks like WMV3 has a sequence header stored in the extradata
441 // advanced sequence header may be before the first frame
442 // the last byte of the extradata is a version number, 1 for the
443 // samples we can decode
445 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
447 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
450 count = avctx->extradata_size*8 - get_bits_count(&gb);
452 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
453 count, get_bits_long(&gb, FFMIN(count, 32)));
454 } else if (count < 0) {
455 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
457 } else { // VC1/WVC1/WVP2
458 const uint8_t *start = avctx->extradata;
459 uint8_t *end = avctx->extradata + avctx->extradata_size;
462 uint8_t *buf2 = NULL;
463 int seq_initialized = 0, ep_initialized = 0;
465 if (avctx->extradata_size < 16) {
466 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
470 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
472 return AVERROR(ENOMEM);
474 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
476 for (; next < end; start = next) {
477 next = find_next_marker(start + 4, end);
478 size = next - start - 4;
481 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
482 init_get_bits(&gb, buf2, buf2_size * 8);
483 switch (AV_RB32(start)) {
484 case VC1_CODE_SEQHDR:
485 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
491 case VC1_CODE_ENTRYPOINT:
492 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
501 if (!seq_initialized || !ep_initialized) {
502 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
505 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
508 avctx->profile = v->profile;
509 if (v->profile == PROFILE_ADVANCED)
510 avctx->level = v->level;
512 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
513 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
515 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
516 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
517 avctx->color_range = AVCOL_RANGE_MPEG;
520 // ensure static VLC tables are initialized
521 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
523 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
525 // Hack to ensure the above functions will be called
526 // again once we know all necessary settings.
527 // That this is necessary might indicate a bug.
528 ff_vc1_decode_end(avctx);
530 ff_blockdsp_init(&s->bdsp, avctx);
531 ff_h264chroma_init(&v->h264chroma, 8);
532 ff_qpeldsp_init(&s->qdsp);
534 // Must happen after calling ff_vc1_decode_end
535 // to avoid de-allocating the sprite_output_frame
536 v->sprite_output_frame = av_frame_alloc();
537 if (!v->sprite_output_frame)
538 return AVERROR(ENOMEM);
540 avctx->has_b_frames = !!avctx->max_b_frames;
542 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
543 avctx->color_primaries = v->color_prim;
544 if (v->transfer_char == 1 || v->transfer_char == 7)
545 avctx->color_trc = v->transfer_char;
546 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
547 avctx->colorspace = v->matrix_coef;
549 s->mb_width = (avctx->coded_width + 15) >> 4;
550 s->mb_height = (avctx->coded_height + 15) >> 4;
552 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
553 ff_vc1_init_transposed_scantables(v);
555 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
560 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
561 v->sprite_width = avctx->coded_width;
562 v->sprite_height = avctx->coded_height;
564 avctx->coded_width = avctx->width = v->output_width;
565 avctx->coded_height = avctx->height = v->output_height;
567 // prevent 16.16 overflows
568 if (v->sprite_width > 1 << 14 ||
569 v->sprite_height > 1 << 14 ||
570 v->output_width > 1 << 14 ||
571 v->output_height > 1 << 14) return -1;
573 if ((v->sprite_width&1) || (v->sprite_height&1)) {
574 avpriv_request_sample(avctx, "odd sprites support");
575 return AVERROR_PATCHWELCOME;
581 /** Close a VC1/WMV3 decoder
582 * @warning Initial try at using MpegEncContext stuff
584 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
586 VC1Context *v = avctx->priv_data;
589 av_frame_free(&v->sprite_output_frame);
591 for (i = 0; i < 4; i++)
592 av_freep(&v->sr_rows[i >> 1][i & 1]);
593 av_freep(&v->hrd_rate);
594 av_freep(&v->hrd_buffer);
595 ff_mpv_common_end(&v->s);
596 av_freep(&v->mv_type_mb_plane);
597 av_freep(&v->direct_mb_plane);
598 av_freep(&v->forward_mb_plane);
599 av_freep(&v->fieldtx_plane);
600 av_freep(&v->acpred_plane);
601 av_freep(&v->over_flags_plane);
602 av_freep(&v->mb_type_base);
603 av_freep(&v->blk_mv_type_base);
604 av_freep(&v->mv_f_base);
605 av_freep(&v->mv_f_next_base);
607 av_freep(&v->cbp_base);
608 av_freep(&v->ttblk_base);
609 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
610 av_freep(&v->luma_mv_base);
611 ff_intrax8_common_end(&v->x8);
616 /** Decode a VC1/WMV3 frame
617 * @todo TODO: Handle VC-1 IDUs (Transport level?)
619 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
620 int *got_frame, AVPacket *avpkt)
622 const uint8_t *buf = avpkt->data;
623 int buf_size = avpkt->size, n_slices = 0, i, ret;
624 VC1Context *v = avctx->priv_data;
625 MpegEncContext *s = &v->s;
626 AVFrame *pict = data;
627 uint8_t *buf2 = NULL;
628 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
629 int mb_height, n_slices1=-1;
634 } *slices = NULL, *tmp;
638 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
641 /* no supplementary picture */
642 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
643 /* special case for last picture */
644 if (s->low_delay == 0 && s->next_picture_ptr) {
645 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
647 s->next_picture_ptr = NULL;
656 if (s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
657 if (v->profile < PROFILE_ADVANCED)
658 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
660 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
664 //for advanced profile we may need to parse and unescape data
665 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
667 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
669 return AVERROR(ENOMEM);
671 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
672 const uint8_t *start, *end, *next;
676 for (start = buf, end = buf + buf_size; next < end; start = next) {
677 next = find_next_marker(start + 4, end);
678 size = next - start - 4;
679 if (size <= 0) continue;
680 switch (AV_RB32(start)) {
684 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
688 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
690 case VC1_CODE_FIELD: {
694 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
697 buf_start_second_field = start;
698 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
700 ret = AVERROR(ENOMEM);
704 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
705 if (!slices[n_slices].buf) {
706 ret = AVERROR(ENOMEM);
709 buf_size3 = vc1_unescape_buffer(start + 4, size,
710 slices[n_slices].buf);
711 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
713 /* assuming that the field marker is at the exact middle,
715 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
716 n_slices1 = n_slices - 1; // index of the last slice of the first field
720 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
721 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
722 init_get_bits(&s->gb, buf2, buf_size2 * 8);
723 ff_vc1_decode_entry_point(avctx, v, &s->gb);
725 case VC1_CODE_SLICE: {
727 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
729 ret = AVERROR(ENOMEM);
733 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
734 if (!slices[n_slices].buf) {
735 ret = AVERROR(ENOMEM);
738 buf_size3 = vc1_unescape_buffer(start + 4, size,
739 slices[n_slices].buf);
740 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
742 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
748 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
749 const uint8_t *divider;
752 divider = find_next_marker(buf, buf + buf_size);
753 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
754 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
755 ret = AVERROR_INVALIDDATA;
757 } else { // found field marker, unescape second field
760 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
763 buf_start_second_field = divider;
764 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
766 ret = AVERROR(ENOMEM);
770 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
771 if (!slices[n_slices].buf) {
772 ret = AVERROR(ENOMEM);
775 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
776 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
778 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
779 n_slices1 = n_slices - 1;
782 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
784 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
786 init_get_bits(&s->gb, buf2, buf_size2*8);
788 init_get_bits(&s->gb, buf, buf_size*8);
791 v->new_sprite = !get_bits1(&s->gb);
792 v->two_sprites = get_bits1(&s->gb);
793 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
794 we're using the sprite compositor. These are intentionally kept separate
795 so you can get the raw sprites by using the wmv3 decoder for WMVP or
796 the vc1 one for WVP2 */
797 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
799 // switch AVCodecContext parameters to those of the sprites
800 avctx->width = avctx->coded_width = v->sprite_width;
801 avctx->height = avctx->coded_height = v->sprite_height;
808 if (s->context_initialized &&
809 (s->width != avctx->coded_width ||
810 s->height != avctx->coded_height)) {
811 ff_vc1_decode_end(avctx);
814 if (!s->context_initialized) {
815 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
817 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
818 ff_mpv_common_end(s);
822 s->low_delay = !avctx->has_b_frames || v->res_sprite;
824 if (v->profile == PROFILE_ADVANCED) {
825 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
826 ret = AVERROR_INVALIDDATA;
829 s->h_edge_pos = avctx->coded_width;
830 s->v_edge_pos = avctx->coded_height;
834 // do parse frame header
835 v->pic_header_flag = 0;
836 v->first_pic_header_flag = 1;
837 if (v->profile < PROFILE_ADVANCED) {
838 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
842 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
846 v->first_pic_header_flag = 0;
848 if (avctx->debug & FF_DEBUG_PICT_INFO)
849 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
851 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
852 && s->pict_type != AV_PICTURE_TYPE_I) {
853 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
854 ret = AVERROR_INVALIDDATA;
858 if ((s->mb_height >> v->field_mode) == 0) {
859 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
860 ret = AVERROR_INVALIDDATA;
864 // for skipping the frame
865 s->current_picture.f->pict_type = s->pict_type;
866 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
868 /* skip B-frames if we don't have reference frames */
869 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
870 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
873 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
874 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
875 avctx->skip_frame >= AVDISCARD_ALL) {
879 if (s->next_p_frame_damaged) {
880 if (s->pict_type == AV_PICTURE_TYPE_B)
883 s->next_p_frame_damaged = 0;
886 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
890 v->s.current_picture_ptr->field_picture = v->field_mode;
891 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
892 v->s.current_picture_ptr->f->top_field_first = v->tff;
894 // process pulldown flags
895 s->current_picture_ptr->f->repeat_pict = 0;
896 // Pulldown flags are only valid when 'broadcast' has been set.
897 // So ticks_per_frame will be 2
900 s->current_picture_ptr->f->repeat_pict = 1;
901 } else if (v->rptfrm) {
903 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
906 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
907 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
910 if ((CONFIG_VC1_VDPAU_DECODER)
911 &&s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
912 if (v->field_mode && buf_start_second_field) {
913 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
914 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
916 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
920 if (avctx->hwaccel) {
921 if (v->field_mode && buf_start_second_field) {
922 // decode first field
923 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
924 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
926 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
928 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
931 // decode second field
932 s->gb = slices[n_slices1 + 1].gb;
933 s->picture_structure = PICT_TOP_FIELD + v->tff;
935 v->pic_header_flag = 0;
936 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
937 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
938 ret = AVERROR_INVALIDDATA;
941 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
943 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
945 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
947 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
950 s->picture_structure = PICT_FRAME;
951 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
953 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
955 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
961 ff_mpeg_er_frame_start(s);
963 v->bits = buf_size * 8;
964 v->end_mb_x = s->mb_width;
966 s->current_picture.f->linesize[0] <<= 1;
967 s->current_picture.f->linesize[1] <<= 1;
968 s->current_picture.f->linesize[2] <<= 1;
972 mb_height = s->mb_height >> v->field_mode;
974 av_assert0 (mb_height > 0);
976 for (i = 0; i <= n_slices; i++) {
977 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
978 if (v->field_mode <= 0) {
979 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
980 "picture boundary (%d >= %d)\n", i,
981 slices[i - 1].mby_start, mb_height);
985 av_assert0((s->mb_height & 1) == 0);
986 v->blocks_off = s->b8_stride * (s->mb_height&~1);
987 v->mb_off = s->mb_stride * s->mb_height >> 1;
994 v->pic_header_flag = 0;
995 if (v->field_mode && i == n_slices1 + 2) {
996 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
997 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
998 ret = AVERROR_INVALIDDATA;
999 if (avctx->err_recognition & AV_EF_EXPLODE)
1003 } else if (get_bits1(&s->gb)) {
1004 v->pic_header_flag = 1;
1005 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1006 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1007 ret = AVERROR_INVALIDDATA;
1008 if (avctx->err_recognition & AV_EF_EXPLODE)
1016 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1017 if (!v->field_mode || v->second_field)
1018 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1020 if (i >= n_slices) {
1021 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1024 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1026 if (s->end_mb_y <= s->start_mb_y) {
1027 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1030 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1031 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1034 ff_vc1_decode_blocks(v);
1036 s->gb = slices[i].gb;
1038 if (v->field_mode) {
1039 v->second_field = 0;
1040 s->current_picture.f->linesize[0] >>= 1;
1041 s->current_picture.f->linesize[1] >>= 1;
1042 s->current_picture.f->linesize[2] >>= 1;
1044 s->uvlinesize >>= 1;
1045 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1046 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1047 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1050 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1051 get_bits_count(&s->gb), s->gb.size_in_bits);
1052 // if (get_bits_count(&s->gb) > buf_size * 8)
1054 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1055 ret = AVERROR_INVALIDDATA;
1059 ff_er_frame_end(&s->er);
1062 ff_mpv_frame_end(s);
1064 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1066 avctx->width = avctx->coded_width = v->output_width;
1067 avctx->height = avctx->coded_height = v->output_height;
1068 if (avctx->skip_frame >= AVDISCARD_NONREF)
1070 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1071 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1074 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1078 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1079 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1081 ff_print_debug_info(s, s->current_picture_ptr, pict);
1083 } else if (s->last_picture_ptr) {
1084 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1086 ff_print_debug_info(s, s->last_picture_ptr, pict);
1093 for (i = 0; i < n_slices; i++)
1094 av_free(slices[i].buf);
1100 for (i = 0; i < n_slices; i++)
1101 av_free(slices[i].buf);
1107 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1108 #if CONFIG_VC1_DXVA2_HWACCEL
1109 AV_PIX_FMT_DXVA2_VLD,
1111 #if CONFIG_VC1_D3D11VA_HWACCEL
1112 AV_PIX_FMT_D3D11VA_VLD,
1114 #if CONFIG_VC1_VAAPI_HWACCEL
1117 #if CONFIG_VC1_VDPAU_HWACCEL
1124 AVCodec ff_vc1_decoder = {
1126 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1127 .type = AVMEDIA_TYPE_VIDEO,
1128 .id = AV_CODEC_ID_VC1,
1129 .priv_data_size = sizeof(VC1Context),
1130 .init = vc1_decode_init,
1131 .close = ff_vc1_decode_end,
1132 .decode = vc1_decode_frame,
1133 .flush = ff_mpeg_flush,
1134 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1135 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1136 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1139 #if CONFIG_WMV3_DECODER
1140 AVCodec ff_wmv3_decoder = {
1142 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1143 .type = AVMEDIA_TYPE_VIDEO,
1144 .id = AV_CODEC_ID_WMV3,
1145 .priv_data_size = sizeof(VC1Context),
1146 .init = vc1_decode_init,
1147 .close = ff_vc1_decode_end,
1148 .decode = vc1_decode_frame,
1149 .flush = ff_mpeg_flush,
1150 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1151 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1152 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1156 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1157 AVCodec ff_wmv3_vdpau_decoder = {
1158 .name = "wmv3_vdpau",
1159 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1160 .type = AVMEDIA_TYPE_VIDEO,
1161 .id = AV_CODEC_ID_WMV3,
1162 .priv_data_size = sizeof(VC1Context),
1163 .init = vc1_decode_init,
1164 .close = ff_vc1_decode_end,
1165 .decode = vc1_decode_frame,
1166 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1167 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1168 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1172 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1173 AVCodec ff_vc1_vdpau_decoder = {
1174 .name = "vc1_vdpau",
1175 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1176 .type = AVMEDIA_TYPE_VIDEO,
1177 .id = AV_CODEC_ID_VC1,
1178 .priv_data_size = sizeof(VC1Context),
1179 .init = vc1_decode_init,
1180 .close = ff_vc1_decode_end,
1181 .decode = vc1_decode_frame,
1182 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1183 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1184 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1188 #if CONFIG_WMV3IMAGE_DECODER
1189 AVCodec ff_wmv3image_decoder = {
1190 .name = "wmv3image",
1191 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1192 .type = AVMEDIA_TYPE_VIDEO,
1193 .id = AV_CODEC_ID_WMV3IMAGE,
1194 .priv_data_size = sizeof(VC1Context),
1195 .init = vc1_decode_init,
1196 .close = ff_vc1_decode_end,
1197 .decode = vc1_decode_frame,
1198 .capabilities = AV_CODEC_CAP_DR1,
1199 .flush = vc1_sprite_flush,
1200 .pix_fmts = (const enum AVPixelFormat[]) {
1207 #if CONFIG_VC1IMAGE_DECODER
1208 AVCodec ff_vc1image_decoder = {
1210 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1211 .type = AVMEDIA_TYPE_VIDEO,
1212 .id = AV_CODEC_ID_VC1IMAGE,
1213 .priv_data_size = sizeof(VC1Context),
1214 .init = vc1_decode_init,
1215 .close = ff_vc1_decode_end,
1216 .decode = vc1_decode_frame,
1217 .capabilities = AV_CODEC_CAP_DR1,
1218 .flush = vc1_sprite_flush,
1219 .pix_fmts = (const enum AVPixelFormat[]) {