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"
35 #include "msmpeg4data.h"
38 #include "vdpau_internal.h"
39 #include "libavutil/avassert.h"
42 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
44 typedef struct SpriteData {
46 * Transform coefficients for both sprites in 16.16 fixed point format,
47 * in the order they appear in the bitstream:
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
63 static inline int get_fp_val(GetBitContext* gb)
65 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
68 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
72 switch (get_bits(gb, 2)) {
75 c[2] = get_fp_val(gb);
79 c[0] = c[4] = get_fp_val(gb);
80 c[2] = get_fp_val(gb);
83 c[0] = get_fp_val(gb);
84 c[2] = get_fp_val(gb);
85 c[4] = get_fp_val(gb);
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);
95 c[5] = get_fp_val(gb);
97 c[6] = get_fp_val(gb);
102 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
104 AVCodecContext *avctx = v->s.avctx;
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");
120 if (sd->effect_type = get_bits_long(gb, 30)) {
121 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
123 vc1_sprite_parse_transform(gb, sd->effect_params1);
126 vc1_sprite_parse_transform(gb, sd->effect_params1);
127 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
130 for (i = 0; i < sd->effect_pcount1; i++)
131 sd->effect_params1[i] = get_fp_val(gb);
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");
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) {
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));
156 av_log(avctx, AV_LOG_DEBUG, "\n");
159 if (sd->effect_flag = get_bits1(gb))
160 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
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;
167 if (get_bits_count(gb) < gb->size_in_bits - 8)
168 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
173 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
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;
180 MpegEncContext *s = &v->s;
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);
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);
191 alpha = av_clip_uint16(sd->coefs[1][6]);
193 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
194 int width = v->output_width>>!!plane;
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;
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;
206 ysub[sprite] = ycoord & 0xFFFF;
208 iplane = s->last_picture.f->data[plane];
209 iline = s->last_picture.f->linesize[plane];
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;
215 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
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]);
222 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
223 sr_cache[sprite][0] = yline;
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;
232 src_h[sprite][0] = v->sr_rows[sprite][0];
233 src_h[sprite][1] = v->sr_rows[sprite][1];
237 if (!v->two_sprites) {
239 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
241 memcpy(dst, src_h[0][0], width);
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);
254 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
260 for (i = 0; i <= v->two_sprites; i++) {
270 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
273 MpegEncContext *s = &v->s;
274 AVCodecContext *avctx = s->avctx;
277 memset(&sd, 0, sizeof(sd));
279 ret = vc1_parse_sprites(v, gb, &sd);
283 if (!s->current_picture.f || !s->current_picture.f->data[0]) {
284 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
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");
293 av_frame_unref(v->sprite_output_frame);
294 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
297 vc1_draw_sprites(v, &sd);
302 static void vc1_sprite_flush(AVCodecContext *avctx)
304 VC1Context *v = avctx->priv_data;
305 MpegEncContext *s = &v->s;
306 AVFrame *f = s->current_picture.f;
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. */
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]);
322 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
324 MpegEncContext *s = &v->s;
326 int mb_height = FFALIGN(s->mb_height, 2);
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);
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;
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);
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);
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)
367 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
371 ff_intrax8_common_init(&v->x8,s);
373 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
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);
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 ||
382 av_freep(&v->mv_type_mb_plane);
383 av_freep(&v->direct_mb_plane);
384 av_freep(&v->acpred_plane);
385 av_freep(&v->over_flags_plane);
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);
398 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
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]);
407 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
413 /** Initialize a VC1/WMV3 decoder
414 * @todo TODO: Handle VC-1 IDUs (Transport level?)
415 * @todo TODO: Decypher remaining bits in extra_data
417 static av_cold int vc1_decode_init(AVCodecContext *avctx)
419 VC1Context *v = avctx->priv_data;
420 MpegEncContext *s = &v->s;
424 /* save the container output size for WMImage */
425 v->output_width = avctx->width;
426 v->output_height = avctx->height;
428 if (!avctx->extradata_size || !avctx->extradata)
430 if (!(avctx->flags & CODEC_FLAG_GRAY))
431 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
433 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
436 if ((ret = ff_vc1_init_common(v)) < 0)
438 // ensure static VLC tables are initialized
439 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
441 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
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);
448 ff_blockdsp_init(&s->bdsp, avctx);
449 ff_h264chroma_init(&v->h264chroma, 8);
450 ff_qpeldsp_init(&s->qdsp);
452 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
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
460 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
462 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
465 count = avctx->extradata_size*8 - get_bits_count(&gb);
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);
472 } else { // VC1/WVC1/WVP2
473 const uint8_t *start = avctx->extradata;
474 uint8_t *end = avctx->extradata + avctx->extradata_size;
477 uint8_t *buf2 = NULL;
478 int seq_initialized = 0, ep_initialized = 0;
480 if (avctx->extradata_size < 16) {
481 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
485 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
487 return AVERROR(ENOMEM);
489 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
491 for (; next < end; start = next) {
492 next = find_next_marker(start + 4, end);
493 size = next - start - 4;
496 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
497 init_get_bits(&gb, buf2, buf2_size * 8);
498 switch (AV_RB32(start)) {
499 case VC1_CODE_SEQHDR:
500 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
506 case VC1_CODE_ENTRYPOINT:
507 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
516 if (!seq_initialized || !ep_initialized) {
517 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
520 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
523 v->sprite_output_frame = av_frame_alloc();
524 if (!v->sprite_output_frame)
525 return AVERROR(ENOMEM);
527 avctx->profile = v->profile;
528 if (v->profile == PROFILE_ADVANCED)
529 avctx->level = v->level;
531 avctx->has_b_frames = !!avctx->max_b_frames;
533 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
534 avctx->color_primaries = v->color_prim;
535 if (v->transfer_char == 1 || v->transfer_char == 7)
536 avctx->color_trc = v->transfer_char;
537 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
538 avctx->colorspace = v->matrix_coef;
540 s->mb_width = (avctx->coded_width + 15) >> 4;
541 s->mb_height = (avctx->coded_height + 15) >> 4;
543 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
544 ff_vc1_init_transposed_scantables(v);
546 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
551 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
552 v->sprite_width = avctx->coded_width;
553 v->sprite_height = avctx->coded_height;
555 avctx->coded_width = avctx->width = v->output_width;
556 avctx->coded_height = avctx->height = v->output_height;
558 // prevent 16.16 overflows
559 if (v->sprite_width > 1 << 14 ||
560 v->sprite_height > 1 << 14 ||
561 v->output_width > 1 << 14 ||
562 v->output_height > 1 << 14) return -1;
564 if ((v->sprite_width&1) || (v->sprite_height&1)) {
565 avpriv_request_sample(avctx, "odd sprites support");
566 return AVERROR_PATCHWELCOME;
572 /** Close a VC1/WMV3 decoder
573 * @warning Initial try at using MpegEncContext stuff
575 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
577 VC1Context *v = avctx->priv_data;
580 av_frame_free(&v->sprite_output_frame);
582 for (i = 0; i < 4; i++)
583 av_freep(&v->sr_rows[i >> 1][i & 1]);
584 av_freep(&v->hrd_rate);
585 av_freep(&v->hrd_buffer);
586 ff_mpv_common_end(&v->s);
587 av_freep(&v->mv_type_mb_plane);
588 av_freep(&v->direct_mb_plane);
589 av_freep(&v->forward_mb_plane);
590 av_freep(&v->fieldtx_plane);
591 av_freep(&v->acpred_plane);
592 av_freep(&v->over_flags_plane);
593 av_freep(&v->mb_type_base);
594 av_freep(&v->blk_mv_type_base);
595 av_freep(&v->mv_f_base);
596 av_freep(&v->mv_f_next_base);
598 av_freep(&v->cbp_base);
599 av_freep(&v->ttblk_base);
600 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
601 av_freep(&v->luma_mv_base);
602 ff_intrax8_common_end(&v->x8);
607 /** Decode a VC1/WMV3 frame
608 * @todo TODO: Handle VC-1 IDUs (Transport level?)
610 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
611 int *got_frame, AVPacket *avpkt)
613 const uint8_t *buf = avpkt->data;
614 int buf_size = avpkt->size, n_slices = 0, i, ret;
615 VC1Context *v = avctx->priv_data;
616 MpegEncContext *s = &v->s;
617 AVFrame *pict = data;
618 uint8_t *buf2 = NULL;
619 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
620 int mb_height, n_slices1=-1;
625 } *slices = NULL, *tmp;
629 if(s->flags & CODEC_FLAG_LOW_DELAY)
632 /* no supplementary picture */
633 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
634 /* special case for last picture */
635 if (s->low_delay == 0 && s->next_picture_ptr) {
636 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
638 s->next_picture_ptr = NULL;
646 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
647 if (v->profile < PROFILE_ADVANCED)
648 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
650 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
653 //for advanced profile we may need to parse and unescape data
654 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
656 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
658 return AVERROR(ENOMEM);
660 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
661 const uint8_t *start, *end, *next;
665 for (start = buf, end = buf + buf_size; next < end; start = next) {
666 next = find_next_marker(start + 4, end);
667 size = next - start - 4;
668 if (size <= 0) continue;
669 switch (AV_RB32(start)) {
671 if (avctx->hwaccel ||
672 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
674 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
676 case VC1_CODE_FIELD: {
678 if (avctx->hwaccel ||
679 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
680 buf_start_second_field = start;
681 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
685 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
686 if (!slices[n_slices].buf)
688 buf_size3 = vc1_unescape_buffer(start + 4, size,
689 slices[n_slices].buf);
690 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
692 /* assuming that the field marker is at the exact middle,
694 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
695 n_slices1 = n_slices - 1; // index of the last slice of the first field
699 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
700 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
701 init_get_bits(&s->gb, buf2, buf_size2 * 8);
702 ff_vc1_decode_entry_point(avctx, v, &s->gb);
704 case VC1_CODE_SLICE: {
706 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
710 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
711 if (!slices[n_slices].buf)
713 buf_size3 = vc1_unescape_buffer(start + 4, size,
714 slices[n_slices].buf);
715 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
717 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
723 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
724 const uint8_t *divider;
727 divider = find_next_marker(buf, buf + buf_size);
728 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
729 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
731 } else { // found field marker, unescape second field
732 if (avctx->hwaccel ||
733 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
734 buf_start_second_field = divider;
735 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
739 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
740 if (!slices[n_slices].buf)
742 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
743 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
745 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
746 n_slices1 = n_slices - 1;
749 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
751 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
753 init_get_bits(&s->gb, buf2, buf_size2*8);
755 init_get_bits(&s->gb, buf, buf_size*8);
758 v->new_sprite = !get_bits1(&s->gb);
759 v->two_sprites = get_bits1(&s->gb);
760 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
761 we're using the sprite compositor. These are intentionally kept separate
762 so you can get the raw sprites by using the wmv3 decoder for WMVP or
763 the vc1 one for WVP2 */
764 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
766 // switch AVCodecContext parameters to those of the sprites
767 avctx->width = avctx->coded_width = v->sprite_width;
768 avctx->height = avctx->coded_height = v->sprite_height;
775 if (s->context_initialized &&
776 (s->width != avctx->coded_width ||
777 s->height != avctx->coded_height)) {
778 ff_vc1_decode_end(avctx);
781 if (!s->context_initialized) {
782 if (ff_msmpeg4_decode_init(avctx) < 0)
784 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
785 ff_mpv_common_end(s);
789 s->low_delay = !avctx->has_b_frames || v->res_sprite;
791 if (v->profile == PROFILE_ADVANCED) {
792 if(avctx->coded_width<=1 || avctx->coded_height<=1)
794 s->h_edge_pos = avctx->coded_width;
795 s->v_edge_pos = avctx->coded_height;
799 // do parse frame header
800 v->pic_header_flag = 0;
801 v->first_pic_header_flag = 1;
802 if (v->profile < PROFILE_ADVANCED) {
803 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
807 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
811 v->first_pic_header_flag = 0;
813 if (avctx->debug & FF_DEBUG_PICT_INFO)
814 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
816 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
817 && s->pict_type != AV_PICTURE_TYPE_I) {
818 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
822 if ((s->mb_height >> v->field_mode) == 0) {
823 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
827 // for skipping the frame
828 s->current_picture.f->pict_type = s->pict_type;
829 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
831 /* skip B-frames if we don't have reference frames */
832 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
833 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
836 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
837 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
838 avctx->skip_frame >= AVDISCARD_ALL) {
842 if (s->next_p_frame_damaged) {
843 if (s->pict_type == AV_PICTURE_TYPE_B)
846 s->next_p_frame_damaged = 0;
849 if (ff_mpv_frame_start(s, avctx) < 0) {
853 v->s.current_picture_ptr->field_picture = v->field_mode;
854 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
855 v->s.current_picture_ptr->f->top_field_first = v->tff;
857 // process pulldown flags
858 s->current_picture_ptr->f->repeat_pict = 0;
859 // Pulldown flags are only valid when 'broadcast' has been set.
860 // So ticks_per_frame will be 2
863 s->current_picture_ptr->f->repeat_pict = 1;
864 } else if (v->rptfrm) {
866 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
869 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
870 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
872 if ((CONFIG_VC1_VDPAU_DECODER)
873 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
874 if (v->field_mode && buf_start_second_field) {
875 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
876 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
878 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
880 } else if (avctx->hwaccel) {
881 if (v->field_mode && buf_start_second_field) {
882 // decode first field
883 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
884 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
886 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
888 if (avctx->hwaccel->end_frame(avctx) < 0)
891 // decode second field
892 s->gb = slices[n_slices1 + 1].gb;
893 s->picture_structure = PICT_TOP_FIELD + v->tff;
895 v->pic_header_flag = 0;
896 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
897 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
900 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
902 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
904 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
906 if (avctx->hwaccel->end_frame(avctx) < 0)
909 s->picture_structure = PICT_FRAME;
910 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
912 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
914 if (avctx->hwaccel->end_frame(avctx) < 0)
920 ff_mpeg_er_frame_start(s);
922 v->bits = buf_size * 8;
923 v->end_mb_x = s->mb_width;
925 s->current_picture.f->linesize[0] <<= 1;
926 s->current_picture.f->linesize[1] <<= 1;
927 s->current_picture.f->linesize[2] <<= 1;
931 mb_height = s->mb_height >> v->field_mode;
933 av_assert0 (mb_height > 0);
935 for (i = 0; i <= n_slices; i++) {
936 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
937 if (v->field_mode <= 0) {
938 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
939 "picture boundary (%d >= %d)\n", i,
940 slices[i - 1].mby_start, mb_height);
944 av_assert0((s->mb_height & 1) == 0);
945 v->blocks_off = s->b8_stride * (s->mb_height&~1);
946 v->mb_off = s->mb_stride * s->mb_height >> 1;
953 v->pic_header_flag = 0;
954 if (v->field_mode && i == n_slices1 + 2) {
955 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
956 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
957 if (avctx->err_recognition & AV_EF_EXPLODE)
961 } else if (get_bits1(&s->gb)) {
962 v->pic_header_flag = 1;
963 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
964 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
965 if (avctx->err_recognition & AV_EF_EXPLODE)
973 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
974 if (!v->field_mode || v->second_field)
975 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
978 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
981 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
983 if (s->end_mb_y <= s->start_mb_y) {
984 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
987 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
988 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
991 ff_vc1_decode_blocks(v);
993 s->gb = slices[i].gb;
997 s->current_picture.f->linesize[0] >>= 1;
998 s->current_picture.f->linesize[1] >>= 1;
999 s->current_picture.f->linesize[2] >>= 1;
1001 s->uvlinesize >>= 1;
1002 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1003 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1004 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1007 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1008 get_bits_count(&s->gb), s->gb.size_in_bits);
1009 // if (get_bits_count(&s->gb) > buf_size * 8)
1011 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
1014 ff_er_frame_end(&s->er);
1017 ff_mpv_frame_end(s);
1019 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1021 avctx->width = avctx->coded_width = v->output_width;
1022 avctx->height = avctx->coded_height = v->output_height;
1023 if (avctx->skip_frame >= AVDISCARD_NONREF)
1025 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1026 if (vc1_decode_sprites(v, &s->gb))
1029 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1033 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1034 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1036 ff_print_debug_info(s, s->current_picture_ptr, pict);
1038 } else if (s->last_picture_ptr) {
1039 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1041 ff_print_debug_info(s, s->last_picture_ptr, pict);
1048 for (i = 0; i < n_slices; i++)
1049 av_free(slices[i].buf);
1055 for (i = 0; i < n_slices; i++)
1056 av_free(slices[i].buf);
1062 static const AVProfile profiles[] = {
1063 { FF_PROFILE_VC1_SIMPLE, "Simple" },
1064 { FF_PROFILE_VC1_MAIN, "Main" },
1065 { FF_PROFILE_VC1_COMPLEX, "Complex" },
1066 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
1067 { FF_PROFILE_UNKNOWN },
1070 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1071 #if CONFIG_VC1_DXVA2_HWACCEL
1072 AV_PIX_FMT_DXVA2_VLD,
1074 #if CONFIG_VC1_VAAPI_HWACCEL
1075 AV_PIX_FMT_VAAPI_VLD,
1077 #if CONFIG_VC1_VDPAU_HWACCEL
1084 AVCodec ff_vc1_decoder = {
1086 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1087 .type = AVMEDIA_TYPE_VIDEO,
1088 .id = AV_CODEC_ID_VC1,
1089 .priv_data_size = sizeof(VC1Context),
1090 .init = vc1_decode_init,
1091 .close = ff_vc1_decode_end,
1092 .decode = vc1_decode_frame,
1093 .flush = ff_mpeg_flush,
1094 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1095 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1096 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1099 #if CONFIG_WMV3_DECODER
1100 AVCodec ff_wmv3_decoder = {
1102 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1103 .type = AVMEDIA_TYPE_VIDEO,
1104 .id = AV_CODEC_ID_WMV3,
1105 .priv_data_size = sizeof(VC1Context),
1106 .init = vc1_decode_init,
1107 .close = ff_vc1_decode_end,
1108 .decode = vc1_decode_frame,
1109 .flush = ff_mpeg_flush,
1110 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1111 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1112 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1116 #if CONFIG_WMV3_VDPAU_DECODER
1117 AVCodec ff_wmv3_vdpau_decoder = {
1118 .name = "wmv3_vdpau",
1119 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1120 .type = AVMEDIA_TYPE_VIDEO,
1121 .id = AV_CODEC_ID_WMV3,
1122 .priv_data_size = sizeof(VC1Context),
1123 .init = vc1_decode_init,
1124 .close = ff_vc1_decode_end,
1125 .decode = vc1_decode_frame,
1126 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
1127 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1128 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1132 #if CONFIG_VC1_VDPAU_DECODER
1133 AVCodec ff_vc1_vdpau_decoder = {
1134 .name = "vc1_vdpau",
1135 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1136 .type = AVMEDIA_TYPE_VIDEO,
1137 .id = AV_CODEC_ID_VC1,
1138 .priv_data_size = sizeof(VC1Context),
1139 .init = vc1_decode_init,
1140 .close = ff_vc1_decode_end,
1141 .decode = vc1_decode_frame,
1142 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
1143 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1144 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1148 #if CONFIG_WMV3IMAGE_DECODER
1149 AVCodec ff_wmv3image_decoder = {
1150 .name = "wmv3image",
1151 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1152 .type = AVMEDIA_TYPE_VIDEO,
1153 .id = AV_CODEC_ID_WMV3IMAGE,
1154 .priv_data_size = sizeof(VC1Context),
1155 .init = vc1_decode_init,
1156 .close = ff_vc1_decode_end,
1157 .decode = vc1_decode_frame,
1158 .capabilities = CODEC_CAP_DR1,
1159 .flush = vc1_sprite_flush,
1160 .pix_fmts = (const enum AVPixelFormat[]) {
1167 #if CONFIG_VC1IMAGE_DECODER
1168 AVCodec ff_vc1image_decoder = {
1170 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1171 .type = AVMEDIA_TYPE_VIDEO,
1172 .id = AV_CODEC_ID_VC1IMAGE,
1173 .priv_data_size = sizeof(VC1Context),
1174 .init = vc1_decode_init,
1175 .close = ff_vc1_decode_end,
1176 .decode = vc1_decode_frame,
1177 .capabilities = CODEC_CAP_DR1,
1178 .flush = vc1_sprite_flush,
1179 .pix_fmts = (const enum AVPixelFormat[]) {