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;
327 int i, ret = AVERROR(ENOMEM);
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);
337 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
338 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
341 v->n_allocated_blks = s->mb_width + 2;
342 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
343 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
344 if (!v->block || !v->cbp_base)
346 v->cbp = v->cbp_base + s->mb_stride;
347 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
350 v->ttblk = v->ttblk_base + s->mb_stride;
351 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
352 if (!v->is_intra_base)
354 v->is_intra = v->is_intra_base + s->mb_stride;
355 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
356 if (!v->luma_mv_base)
358 v->luma_mv = v->luma_mv_base + s->mb_stride;
360 /* allocate block type info in that way so it could be used with s->block_index[] */
361 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362 if (!v->mb_type_base)
364 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
365 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
368 /* allocate memory to store block level MV info */
369 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370 if (!v->blk_mv_type_base)
372 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
373 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
376 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
377 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379 if (!v->mv_f_next_base)
381 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
382 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
384 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
385 for (i = 0; i < 4; i++)
386 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
387 return AVERROR(ENOMEM);
390 ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp, s);
397 ff_vc1_decode_end(s->avctx);
401 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
404 for (i = 0; i < 64; i++) {
405 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
406 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
407 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
408 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
409 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
410 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
416 /** Initialize a VC1/WMV3 decoder
417 * @todo TODO: Handle VC-1 IDUs (Transport level?)
418 * @todo TODO: Decypher remaining bits in extra_data
420 static av_cold int vc1_decode_init(AVCodecContext *avctx)
422 VC1Context *v = avctx->priv_data;
423 MpegEncContext *s = &v->s;
427 /* save the container output size for WMImage */
428 v->output_width = avctx->width;
429 v->output_height = avctx->height;
431 if (!avctx->extradata_size || !avctx->extradata)
435 if ((ret = ff_vc1_init_common(v)) < 0)
438 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
441 // looks like WMV3 has a sequence header stored in the extradata
442 // advanced sequence header may be before the first frame
443 // the last byte of the extradata is a version number, 1 for the
444 // samples we can decode
446 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
448 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
451 count = avctx->extradata_size*8 - get_bits_count(&gb);
453 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
454 count, get_bits_long(&gb, FFMIN(count, 32)));
455 } else if (count < 0) {
456 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
458 } else { // VC1/WVC1/WVP2
459 const uint8_t *start = avctx->extradata;
460 uint8_t *end = avctx->extradata + avctx->extradata_size;
463 uint8_t *buf2 = NULL;
464 int seq_initialized = 0, ep_initialized = 0;
466 if (avctx->extradata_size < 16) {
467 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
471 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
473 return AVERROR(ENOMEM);
475 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
477 for (; next < end; start = next) {
478 next = find_next_marker(start + 4, end);
479 size = next - start - 4;
482 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
483 init_get_bits(&gb, buf2, buf2_size * 8);
484 switch (AV_RB32(start)) {
485 case VC1_CODE_SEQHDR:
486 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
492 case VC1_CODE_ENTRYPOINT:
493 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
502 if (!seq_initialized || !ep_initialized) {
503 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
506 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
509 avctx->profile = v->profile;
510 if (v->profile == PROFILE_ADVANCED)
511 avctx->level = v->level;
513 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
514 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
516 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
517 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
518 avctx->color_range = AVCOL_RANGE_MPEG;
521 // ensure static VLC tables are initialized
522 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
524 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
526 // Hack to ensure the above functions will be called
527 // again once we know all necessary settings.
528 // That this is necessary might indicate a bug.
529 ff_vc1_decode_end(avctx);
531 ff_blockdsp_init(&s->bdsp, avctx);
532 ff_h264chroma_init(&v->h264chroma, 8);
533 ff_qpeldsp_init(&s->qdsp);
535 // Must happen after calling ff_vc1_decode_end
536 // to avoid de-allocating the sprite_output_frame
537 v->sprite_output_frame = av_frame_alloc();
538 if (!v->sprite_output_frame)
539 return AVERROR(ENOMEM);
541 avctx->has_b_frames = !!avctx->max_b_frames;
543 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
544 avctx->color_primaries = v->color_prim;
545 if (v->transfer_char == 1 || v->transfer_char == 7)
546 avctx->color_trc = v->transfer_char;
547 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
548 avctx->colorspace = v->matrix_coef;
550 s->mb_width = (avctx->coded_width + 15) >> 4;
551 s->mb_height = (avctx->coded_height + 15) >> 4;
553 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
554 ff_vc1_init_transposed_scantables(v);
556 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
561 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
562 v->sprite_width = avctx->coded_width;
563 v->sprite_height = avctx->coded_height;
565 avctx->coded_width = avctx->width = v->output_width;
566 avctx->coded_height = avctx->height = v->output_height;
568 // prevent 16.16 overflows
569 if (v->sprite_width > 1 << 14 ||
570 v->sprite_height > 1 << 14 ||
571 v->output_width > 1 << 14 ||
572 v->output_height > 1 << 14) return -1;
574 if ((v->sprite_width&1) || (v->sprite_height&1)) {
575 avpriv_request_sample(avctx, "odd sprites support");
576 return AVERROR_PATCHWELCOME;
582 /** Close a VC1/WMV3 decoder
583 * @warning Initial try at using MpegEncContext stuff
585 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
587 VC1Context *v = avctx->priv_data;
590 av_frame_free(&v->sprite_output_frame);
592 for (i = 0; i < 4; i++)
593 av_freep(&v->sr_rows[i >> 1][i & 1]);
594 av_freep(&v->hrd_rate);
595 av_freep(&v->hrd_buffer);
596 ff_mpv_common_end(&v->s);
597 av_freep(&v->mv_type_mb_plane);
598 av_freep(&v->direct_mb_plane);
599 av_freep(&v->forward_mb_plane);
600 av_freep(&v->fieldtx_plane);
601 av_freep(&v->acpred_plane);
602 av_freep(&v->over_flags_plane);
603 av_freep(&v->mb_type_base);
604 av_freep(&v->blk_mv_type_base);
605 av_freep(&v->mv_f_base);
606 av_freep(&v->mv_f_next_base);
608 av_freep(&v->cbp_base);
609 av_freep(&v->ttblk_base);
610 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
611 av_freep(&v->luma_mv_base);
612 ff_intrax8_common_end(&v->x8);
617 /** Decode a VC1/WMV3 frame
618 * @todo TODO: Handle VC-1 IDUs (Transport level?)
620 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
621 int *got_frame, AVPacket *avpkt)
623 const uint8_t *buf = avpkt->data;
624 int buf_size = avpkt->size, n_slices = 0, i, ret;
625 VC1Context *v = avctx->priv_data;
626 MpegEncContext *s = &v->s;
627 AVFrame *pict = data;
628 uint8_t *buf2 = NULL;
629 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
630 int mb_height, n_slices1=-1;
635 } *slices = NULL, *tmp;
639 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
642 /* no supplementary picture */
643 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
644 /* special case for last picture */
645 if (s->low_delay == 0 && s->next_picture_ptr) {
646 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
648 s->next_picture_ptr = NULL;
657 if (s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
658 if (v->profile < PROFILE_ADVANCED)
659 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
661 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
665 //for advanced profile we may need to parse and unescape data
666 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
668 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
670 return AVERROR(ENOMEM);
672 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
673 const uint8_t *start, *end, *next;
677 for (start = buf, end = buf + buf_size; next < end; start = next) {
678 next = find_next_marker(start + 4, end);
679 size = next - start - 4;
680 if (size <= 0) continue;
681 switch (AV_RB32(start)) {
685 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
689 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
691 case VC1_CODE_FIELD: {
695 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
698 buf_start_second_field = start;
699 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
701 ret = AVERROR(ENOMEM);
705 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
706 if (!slices[n_slices].buf) {
707 ret = AVERROR(ENOMEM);
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,
714 /* assuming that the field marker is at the exact middle,
716 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
717 n_slices1 = n_slices - 1; // index of the last slice of the first field
721 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
722 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
723 init_get_bits(&s->gb, buf2, buf_size2 * 8);
724 ff_vc1_decode_entry_point(avctx, v, &s->gb);
726 case VC1_CODE_SLICE: {
728 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
730 ret = AVERROR(ENOMEM);
734 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
735 if (!slices[n_slices].buf) {
736 ret = AVERROR(ENOMEM);
739 buf_size3 = vc1_unescape_buffer(start + 4, size,
740 slices[n_slices].buf);
741 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
743 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
749 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
750 const uint8_t *divider;
753 divider = find_next_marker(buf, buf + buf_size);
754 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
755 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
756 ret = AVERROR_INVALIDDATA;
758 } else { // found field marker, unescape second field
761 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
764 buf_start_second_field = divider;
765 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
767 ret = AVERROR(ENOMEM);
771 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
772 if (!slices[n_slices].buf) {
773 ret = AVERROR(ENOMEM);
776 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
777 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
779 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
780 n_slices1 = n_slices - 1;
783 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
785 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
787 init_get_bits(&s->gb, buf2, buf_size2*8);
789 init_get_bits(&s->gb, buf, buf_size*8);
792 v->new_sprite = !get_bits1(&s->gb);
793 v->two_sprites = get_bits1(&s->gb);
794 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
795 we're using the sprite compositor. These are intentionally kept separate
796 so you can get the raw sprites by using the wmv3 decoder for WMVP or
797 the vc1 one for WVP2 */
798 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
800 // switch AVCodecContext parameters to those of the sprites
801 avctx->width = avctx->coded_width = v->sprite_width;
802 avctx->height = avctx->coded_height = v->sprite_height;
809 if (s->context_initialized &&
810 (s->width != avctx->coded_width ||
811 s->height != avctx->coded_height)) {
812 ff_vc1_decode_end(avctx);
815 if (!s->context_initialized) {
816 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
818 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
819 ff_mpv_common_end(s);
823 s->low_delay = !avctx->has_b_frames || v->res_sprite;
825 if (v->profile == PROFILE_ADVANCED) {
826 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
827 ret = AVERROR_INVALIDDATA;
830 s->h_edge_pos = avctx->coded_width;
831 s->v_edge_pos = avctx->coded_height;
835 // do parse frame header
836 v->pic_header_flag = 0;
837 v->first_pic_header_flag = 1;
838 if (v->profile < PROFILE_ADVANCED) {
839 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
843 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
847 v->first_pic_header_flag = 0;
849 if (avctx->debug & FF_DEBUG_PICT_INFO)
850 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
852 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
853 && s->pict_type != AV_PICTURE_TYPE_I) {
854 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
855 ret = AVERROR_INVALIDDATA;
859 if ((s->mb_height >> v->field_mode) == 0) {
860 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
861 ret = AVERROR_INVALIDDATA;
865 // for skipping the frame
866 s->current_picture.f->pict_type = s->pict_type;
867 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
869 /* skip B-frames if we don't have reference frames */
870 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
871 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
874 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
875 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
876 avctx->skip_frame >= AVDISCARD_ALL) {
880 if (s->next_p_frame_damaged) {
881 if (s->pict_type == AV_PICTURE_TYPE_B)
884 s->next_p_frame_damaged = 0;
887 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
891 v->s.current_picture_ptr->field_picture = v->field_mode;
892 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
893 v->s.current_picture_ptr->f->top_field_first = v->tff;
895 // process pulldown flags
896 s->current_picture_ptr->f->repeat_pict = 0;
897 // Pulldown flags are only valid when 'broadcast' has been set.
898 // So ticks_per_frame will be 2
901 s->current_picture_ptr->f->repeat_pict = 1;
902 } else if (v->rptfrm) {
904 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
907 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
908 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
911 if ((CONFIG_VC1_VDPAU_DECODER)
912 &&s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
913 if (v->field_mode && buf_start_second_field) {
914 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
915 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
917 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
921 if (avctx->hwaccel) {
922 if (v->field_mode && buf_start_second_field) {
923 // decode first field
924 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
925 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
927 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
929 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
932 // decode second field
933 s->gb = slices[n_slices1 + 1].gb;
934 s->picture_structure = PICT_TOP_FIELD + v->tff;
936 v->pic_header_flag = 0;
937 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
938 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
939 ret = AVERROR_INVALIDDATA;
942 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
944 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
946 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
948 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
951 s->picture_structure = PICT_FRAME;
952 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
954 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
956 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
962 ff_mpeg_er_frame_start(s);
964 v->bits = buf_size * 8;
965 v->end_mb_x = s->mb_width;
967 s->current_picture.f->linesize[0] <<= 1;
968 s->current_picture.f->linesize[1] <<= 1;
969 s->current_picture.f->linesize[2] <<= 1;
973 mb_height = s->mb_height >> v->field_mode;
975 av_assert0 (mb_height > 0);
977 for (i = 0; i <= n_slices; i++) {
978 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
979 if (v->field_mode <= 0) {
980 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
981 "picture boundary (%d >= %d)\n", i,
982 slices[i - 1].mby_start, mb_height);
986 av_assert0((s->mb_height & 1) == 0);
987 v->blocks_off = s->b8_stride * (s->mb_height&~1);
988 v->mb_off = s->mb_stride * s->mb_height >> 1;
995 v->pic_header_flag = 0;
996 if (v->field_mode && i == n_slices1 + 2) {
997 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
998 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
999 ret = AVERROR_INVALIDDATA;
1000 if (avctx->err_recognition & AV_EF_EXPLODE)
1004 } else if (get_bits1(&s->gb)) {
1005 v->pic_header_flag = 1;
1006 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1007 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1008 ret = AVERROR_INVALIDDATA;
1009 if (avctx->err_recognition & AV_EF_EXPLODE)
1017 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1018 if (!v->field_mode || v->second_field)
1019 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1021 if (i >= n_slices) {
1022 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1025 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1027 if (s->end_mb_y <= s->start_mb_y) {
1028 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1031 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1032 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1035 ff_vc1_decode_blocks(v);
1037 s->gb = slices[i].gb;
1039 if (v->field_mode) {
1040 v->second_field = 0;
1041 s->current_picture.f->linesize[0] >>= 1;
1042 s->current_picture.f->linesize[1] >>= 1;
1043 s->current_picture.f->linesize[2] >>= 1;
1045 s->uvlinesize >>= 1;
1046 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1047 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1048 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1051 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1052 get_bits_count(&s->gb), s->gb.size_in_bits);
1053 // if (get_bits_count(&s->gb) > buf_size * 8)
1055 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1056 ret = AVERROR_INVALIDDATA;
1060 ff_er_frame_end(&s->er);
1063 ff_mpv_frame_end(s);
1065 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1067 avctx->width = avctx->coded_width = v->output_width;
1068 avctx->height = avctx->coded_height = v->output_height;
1069 if (avctx->skip_frame >= AVDISCARD_NONREF)
1071 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1072 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1075 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1079 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1080 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1082 ff_print_debug_info(s, s->current_picture_ptr, pict);
1084 } else if (s->last_picture_ptr) {
1085 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1087 ff_print_debug_info(s, s->last_picture_ptr, pict);
1094 for (i = 0; i < n_slices; i++)
1095 av_free(slices[i].buf);
1101 for (i = 0; i < n_slices; i++)
1102 av_free(slices[i].buf);
1108 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1109 #if CONFIG_VC1_DXVA2_HWACCEL
1110 AV_PIX_FMT_DXVA2_VLD,
1112 #if CONFIG_VC1_D3D11VA_HWACCEL
1113 AV_PIX_FMT_D3D11VA_VLD,
1115 #if CONFIG_VC1_VAAPI_HWACCEL
1118 #if CONFIG_VC1_VDPAU_HWACCEL
1125 AVCodec ff_vc1_decoder = {
1127 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1128 .type = AVMEDIA_TYPE_VIDEO,
1129 .id = AV_CODEC_ID_VC1,
1130 .priv_data_size = sizeof(VC1Context),
1131 .init = vc1_decode_init,
1132 .close = ff_vc1_decode_end,
1133 .decode = vc1_decode_frame,
1134 .flush = ff_mpeg_flush,
1135 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1136 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1137 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1140 #if CONFIG_WMV3_DECODER
1141 AVCodec ff_wmv3_decoder = {
1143 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1144 .type = AVMEDIA_TYPE_VIDEO,
1145 .id = AV_CODEC_ID_WMV3,
1146 .priv_data_size = sizeof(VC1Context),
1147 .init = vc1_decode_init,
1148 .close = ff_vc1_decode_end,
1149 .decode = vc1_decode_frame,
1150 .flush = ff_mpeg_flush,
1151 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1152 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1153 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1157 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1158 AVCodec ff_wmv3_vdpau_decoder = {
1159 .name = "wmv3_vdpau",
1160 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1161 .type = AVMEDIA_TYPE_VIDEO,
1162 .id = AV_CODEC_ID_WMV3,
1163 .priv_data_size = sizeof(VC1Context),
1164 .init = vc1_decode_init,
1165 .close = ff_vc1_decode_end,
1166 .decode = vc1_decode_frame,
1167 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1168 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1169 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1173 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1174 AVCodec ff_vc1_vdpau_decoder = {
1175 .name = "vc1_vdpau",
1176 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1177 .type = AVMEDIA_TYPE_VIDEO,
1178 .id = AV_CODEC_ID_VC1,
1179 .priv_data_size = sizeof(VC1Context),
1180 .init = vc1_decode_init,
1181 .close = ff_vc1_decode_end,
1182 .decode = vc1_decode_frame,
1183 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1184 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1185 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1189 #if CONFIG_WMV3IMAGE_DECODER
1190 AVCodec ff_wmv3image_decoder = {
1191 .name = "wmv3image",
1192 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1193 .type = AVMEDIA_TYPE_VIDEO,
1194 .id = AV_CODEC_ID_WMV3IMAGE,
1195 .priv_data_size = sizeof(VC1Context),
1196 .init = vc1_decode_init,
1197 .close = ff_vc1_decode_end,
1198 .decode = vc1_decode_frame,
1199 .capabilities = AV_CODEC_CAP_DR1,
1200 .flush = vc1_sprite_flush,
1201 .pix_fmts = (const enum AVPixelFormat[]) {
1208 #if CONFIG_VC1IMAGE_DECODER
1209 AVCodec ff_vc1image_decoder = {
1211 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1212 .type = AVMEDIA_TYPE_VIDEO,
1213 .id = AV_CODEC_ID_VC1IMAGE,
1214 .priv_data_size = sizeof(VC1Context),
1215 .init = vc1_decode_init,
1216 .close = ff_vc1_decode_end,
1217 .decode = vc1_decode_frame,
1218 .capabilities = AV_CODEC_CAP_DR1,
1219 .flush = vc1_sprite_flush,
1220 .pix_fmts = (const enum AVPixelFormat[]) {