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 "libavutil/avassert.h"
43 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
45 typedef struct SpriteData {
47 * Transform coefficients for both sprites in 16.16 fixed point format,
48 * in the order they appear in the bitstream:
59 int effect_type, effect_flag;
60 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
61 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
64 static inline int get_fp_val(GetBitContext* gb)
66 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
69 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
73 switch (get_bits(gb, 2)) {
76 c[2] = get_fp_val(gb);
80 c[0] = c[4] = get_fp_val(gb);
81 c[2] = get_fp_val(gb);
84 c[0] = get_fp_val(gb);
85 c[2] = get_fp_val(gb);
86 c[4] = get_fp_val(gb);
89 c[0] = get_fp_val(gb);
90 c[1] = get_fp_val(gb);
91 c[2] = get_fp_val(gb);
92 c[3] = get_fp_val(gb);
93 c[4] = get_fp_val(gb);
96 c[5] = get_fp_val(gb);
98 c[6] = get_fp_val(gb);
103 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
105 AVCodecContext *avctx = v->s.avctx;
108 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
109 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
110 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
111 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
112 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
113 for (i = 0; i < 7; i++)
114 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
115 sd->coefs[sprite][i] / (1<<16),
116 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
117 av_log(avctx, AV_LOG_DEBUG, "\n");
121 if (sd->effect_type = get_bits_long(gb, 30)) {
122 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
124 vc1_sprite_parse_transform(gb, sd->effect_params1);
127 vc1_sprite_parse_transform(gb, sd->effect_params1);
128 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
131 for (i = 0; i < sd->effect_pcount1; i++)
132 sd->effect_params1[i] = get_fp_val(gb);
134 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
135 // effect 13 is simple alpha blending and matches the opacity above
136 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
137 for (i = 0; i < sd->effect_pcount1; i++)
138 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
139 sd->effect_params1[i] / (1 << 16),
140 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
141 av_log(avctx, AV_LOG_DEBUG, "\n");
144 sd->effect_pcount2 = get_bits(gb, 16);
145 if (sd->effect_pcount2 > 10) {
146 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
147 return AVERROR_INVALIDDATA;
148 } else if (sd->effect_pcount2) {
150 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
151 while (++i < sd->effect_pcount2) {
152 sd->effect_params2[i] = get_fp_val(gb);
153 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
154 sd->effect_params2[i] / (1 << 16),
155 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
157 av_log(avctx, AV_LOG_DEBUG, "\n");
160 if (sd->effect_flag = get_bits1(gb))
161 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
163 if (get_bits_count(gb) >= gb->size_in_bits +
164 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
165 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
166 return AVERROR_INVALIDDATA;
168 if (get_bits_count(gb) < gb->size_in_bits - 8)
169 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
174 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
176 int i, plane, row, sprite;
177 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
178 uint8_t* src_h[2][2];
179 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
181 MpegEncContext *s = &v->s;
183 for (i = 0; i <= v->two_sprites; i++) {
184 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
185 xadv[i] = sd->coefs[i][0];
186 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
187 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
189 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
190 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
192 alpha = av_clip_uint16(sd->coefs[1][6]);
194 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
195 int width = v->output_width>>!!plane;
197 for (row = 0; row < v->output_height>>!!plane; row++) {
198 uint8_t *dst = v->sprite_output_frame->data[plane] +
199 v->sprite_output_frame->linesize[plane] * row;
201 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
202 uint8_t *iplane = s->current_picture.f->data[plane];
203 int iline = s->current_picture.f->linesize[plane];
204 int ycoord = yoff[sprite] + yadv[sprite] * row;
205 int yline = ycoord >> 16;
207 ysub[sprite] = ycoord & 0xFFFF;
209 iplane = s->last_picture.f->data[plane];
210 iline = s->last_picture.f->linesize[plane];
212 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
213 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
214 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
216 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
218 if (sr_cache[sprite][0] != yline) {
219 if (sr_cache[sprite][1] == yline) {
220 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
221 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
223 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
224 sr_cache[sprite][0] = yline;
227 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
228 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
229 iplane + next_line, xoff[sprite],
230 xadv[sprite], width);
231 sr_cache[sprite][1] = yline + 1;
233 src_h[sprite][0] = v->sr_rows[sprite][0];
234 src_h[sprite][1] = v->sr_rows[sprite][1];
238 if (!v->two_sprites) {
240 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
242 memcpy(dst, src_h[0][0], width);
245 if (ysub[0] && ysub[1]) {
246 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
247 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
248 } else if (ysub[0]) {
249 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
250 src_h[1][0], alpha, width);
251 } else if (ysub[1]) {
252 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
253 src_h[0][0], (1<<16)-1-alpha, width);
255 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
261 for (i = 0; i <= v->two_sprites; i++) {
271 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
274 MpegEncContext *s = &v->s;
275 AVCodecContext *avctx = s->avctx;
278 memset(&sd, 0, sizeof(sd));
280 ret = vc1_parse_sprites(v, gb, &sd);
284 if (!s->current_picture.f || !s->current_picture.f->data[0]) {
285 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
286 return AVERROR_UNKNOWN;
289 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
290 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
294 av_frame_unref(v->sprite_output_frame);
295 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
298 vc1_draw_sprites(v, &sd);
303 static void vc1_sprite_flush(AVCodecContext *avctx)
305 VC1Context *v = avctx->priv_data;
306 MpegEncContext *s = &v->s;
307 AVFrame *f = s->current_picture.f;
310 /* Windows Media Image codecs have a convergence interval of two keyframes.
311 Since we can't enforce it, clear to black the missing sprite. This is
312 wrong but it looks better than doing nothing. */
315 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
316 for (i = 0; i < v->sprite_height>>!!plane; i++)
317 memset(f->data[plane] + i * f->linesize[plane],
318 plane ? 128 : 0, f->linesize[plane]);
323 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
325 MpegEncContext *s = &v->s;
326 int i, ret = AVERROR(ENOMEM);
327 int mb_height = FFALIGN(s->mb_height, 2);
329 /* Allocate mb bitplanes */
330 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
331 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
332 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
333 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
334 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
335 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
336 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
337 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
340 v->n_allocated_blks = s->mb_width + 2;
341 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
342 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
343 if (!v->block || !v->cbp_base)
345 v->cbp = v->cbp_base + s->mb_stride;
346 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
349 v->ttblk = v->ttblk_base + s->mb_stride;
350 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
351 if (!v->is_intra_base)
353 v->is_intra = v->is_intra_base + s->mb_stride;
354 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
355 if (!v->luma_mv_base)
357 v->luma_mv = v->luma_mv_base + s->mb_stride;
359 /* allocate block type info in that way so it could be used with s->block_index[] */
360 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
361 if (!v->mb_type_base)
363 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
364 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
365 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
367 /* allocate memory to store block level MV info */
368 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
369 if (!v->blk_mv_type_base)
371 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
372 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
375 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
376 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
377 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
378 if (!v->mv_f_next_base)
380 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
381 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
383 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
384 for (i = 0; i < 4; i++)
385 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
386 return AVERROR(ENOMEM);
389 ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp,
390 s->block, s->block_last_index,
391 s->mb_width, s->mb_height);
398 ff_vc1_decode_end(s->avctx);
402 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
405 for (i = 0; i < 64; i++) {
406 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
407 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
408 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
409 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
410 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
411 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
417 /** Initialize a VC1/WMV3 decoder
418 * @todo TODO: Handle VC-1 IDUs (Transport level?)
419 * @todo TODO: Decipher remaining bits in extra_data
421 static av_cold int vc1_decode_init(AVCodecContext *avctx)
423 VC1Context *v = avctx->priv_data;
424 MpegEncContext *s = &v->s;
428 /* save the container output size for WMImage */
429 v->output_width = avctx->width;
430 v->output_height = avctx->height;
432 if (!avctx->extradata_size || !avctx->extradata)
436 if ((ret = ff_vc1_init_common(v)) < 0)
439 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
442 // looks like WMV3 has a sequence header stored in the extradata
443 // advanced sequence header may be before the first frame
444 // the last byte of the extradata is a version number, 1 for the
445 // samples we can decode
447 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
449 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
452 count = avctx->extradata_size*8 - get_bits_count(&gb);
454 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
455 count, get_bits_long(&gb, FFMIN(count, 32)));
456 } else if (count < 0) {
457 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
459 } else { // VC1/WVC1/WVP2
460 const uint8_t *start = avctx->extradata;
461 uint8_t *end = avctx->extradata + avctx->extradata_size;
464 uint8_t *buf2 = NULL;
465 int seq_initialized = 0, ep_initialized = 0;
467 if (avctx->extradata_size < 16) {
468 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
472 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
474 return AVERROR(ENOMEM);
476 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
478 for (; next < end; start = next) {
479 next = find_next_marker(start + 4, end);
480 size = next - start - 4;
483 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
484 init_get_bits(&gb, buf2, buf2_size * 8);
485 switch (AV_RB32(start)) {
486 case VC1_CODE_SEQHDR:
487 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
493 case VC1_CODE_ENTRYPOINT:
494 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
503 if (!seq_initialized || !ep_initialized) {
504 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
507 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
510 avctx->profile = v->profile;
511 if (v->profile == PROFILE_ADVANCED)
512 avctx->level = v->level;
514 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
515 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
517 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
518 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
519 avctx->color_range = AVCOL_RANGE_MPEG;
522 // ensure static VLC tables are initialized
523 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
525 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
527 // Hack to ensure the above functions will be called
528 // again once we know all necessary settings.
529 // That this is necessary might indicate a bug.
530 ff_vc1_decode_end(avctx);
532 ff_blockdsp_init(&s->bdsp, avctx);
533 ff_h264chroma_init(&v->h264chroma, 8);
534 ff_qpeldsp_init(&s->qdsp);
536 // Must happen after calling ff_vc1_decode_end
537 // to avoid de-allocating the sprite_output_frame
538 v->sprite_output_frame = av_frame_alloc();
539 if (!v->sprite_output_frame)
540 return AVERROR(ENOMEM);
542 avctx->has_b_frames = !!avctx->max_b_frames;
544 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
545 avctx->color_primaries = v->color_prim;
546 if (v->transfer_char == 1 || v->transfer_char == 7)
547 avctx->color_trc = v->transfer_char;
548 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
549 avctx->colorspace = v->matrix_coef;
551 s->mb_width = (avctx->coded_width + 15) >> 4;
552 s->mb_height = (avctx->coded_height + 15) >> 4;
554 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
555 ff_vc1_init_transposed_scantables(v);
557 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
562 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
563 v->sprite_width = avctx->coded_width;
564 v->sprite_height = avctx->coded_height;
566 avctx->coded_width = avctx->width = v->output_width;
567 avctx->coded_height = avctx->height = v->output_height;
569 // prevent 16.16 overflows
570 if (v->sprite_width > 1 << 14 ||
571 v->sprite_height > 1 << 14 ||
572 v->output_width > 1 << 14 ||
573 v->output_height > 1 << 14) return -1;
575 if ((v->sprite_width&1) || (v->sprite_height&1)) {
576 avpriv_request_sample(avctx, "odd sprites support");
577 return AVERROR_PATCHWELCOME;
583 /** Close a VC1/WMV3 decoder
584 * @warning Initial try at using MpegEncContext stuff
586 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
588 VC1Context *v = avctx->priv_data;
591 av_frame_free(&v->sprite_output_frame);
593 for (i = 0; i < 4; i++)
594 av_freep(&v->sr_rows[i >> 1][i & 1]);
595 av_freep(&v->hrd_rate);
596 av_freep(&v->hrd_buffer);
597 ff_mpv_common_end(&v->s);
598 av_freep(&v->mv_type_mb_plane);
599 av_freep(&v->direct_mb_plane);
600 av_freep(&v->forward_mb_plane);
601 av_freep(&v->fieldtx_plane);
602 av_freep(&v->acpred_plane);
603 av_freep(&v->over_flags_plane);
604 av_freep(&v->mb_type_base);
605 av_freep(&v->blk_mv_type_base);
606 av_freep(&v->mv_f_base);
607 av_freep(&v->mv_f_next_base);
609 av_freep(&v->cbp_base);
610 av_freep(&v->ttblk_base);
611 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
612 av_freep(&v->luma_mv_base);
613 ff_intrax8_common_end(&v->x8);
618 /** Decode a VC1/WMV3 frame
619 * @todo TODO: Handle VC-1 IDUs (Transport level?)
621 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
622 int *got_frame, AVPacket *avpkt)
624 const uint8_t *buf = avpkt->data;
625 int buf_size = avpkt->size, n_slices = 0, i, ret;
626 VC1Context *v = avctx->priv_data;
627 MpegEncContext *s = &v->s;
628 AVFrame *pict = data;
629 uint8_t *buf2 = NULL;
630 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
631 int mb_height, n_slices1=-1;
636 const uint8_t *rawbuf;
638 } *slices = NULL, *tmp;
642 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
645 /* no supplementary picture */
646 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
647 /* special case for last picture */
648 if (s->low_delay == 0 && s->next_picture_ptr) {
649 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
651 s->next_picture_ptr = NULL;
659 //for advanced profile we may need to parse and unescape data
660 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
662 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
664 return AVERROR(ENOMEM);
666 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
667 const uint8_t *start, *end, *next;
671 for (start = buf, end = buf + buf_size; next < end; start = next) {
672 next = find_next_marker(start + 4, end);
673 size = next - start - 4;
674 if (size <= 0) continue;
675 switch (AV_RB32(start)) {
679 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
681 case VC1_CODE_FIELD: {
684 buf_start_second_field = start;
685 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
687 ret = AVERROR(ENOMEM);
691 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
692 if (!slices[n_slices].buf) {
693 ret = AVERROR(ENOMEM);
696 buf_size3 = vc1_unescape_buffer(start + 4, size,
697 slices[n_slices].buf);
698 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
700 /* assuming that the field marker is at the exact middle,
702 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
703 slices[n_slices].rawbuf = start;
704 slices[n_slices].raw_size = size + 4;
705 n_slices1 = n_slices - 1; // index of the last slice of the first field
709 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
710 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
711 init_get_bits(&s->gb, buf2, buf_size2 * 8);
712 ff_vc1_decode_entry_point(avctx, v, &s->gb);
714 case VC1_CODE_SLICE: {
716 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
718 ret = AVERROR(ENOMEM);
722 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
723 if (!slices[n_slices].buf) {
724 ret = AVERROR(ENOMEM);
727 buf_size3 = vc1_unescape_buffer(start + 4, size,
728 slices[n_slices].buf);
729 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
731 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
732 slices[n_slices].rawbuf = start;
733 slices[n_slices].raw_size = size + 4;
739 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
740 const uint8_t *divider;
743 divider = find_next_marker(buf, buf + buf_size);
744 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
745 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
746 ret = AVERROR_INVALIDDATA;
748 } else { // found field marker, unescape second field
750 buf_start_second_field = divider;
751 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
753 ret = AVERROR(ENOMEM);
757 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
758 if (!slices[n_slices].buf) {
759 ret = AVERROR(ENOMEM);
762 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
763 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
765 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
766 slices[n_slices].rawbuf = divider;
767 slices[n_slices].raw_size = buf + buf_size - divider;
768 n_slices1 = n_slices - 1;
771 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
773 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
775 init_get_bits(&s->gb, buf2, buf_size2*8);
777 init_get_bits(&s->gb, buf, buf_size*8);
780 v->new_sprite = !get_bits1(&s->gb);
781 v->two_sprites = get_bits1(&s->gb);
782 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
783 we're using the sprite compositor. These are intentionally kept separate
784 so you can get the raw sprites by using the wmv3 decoder for WMVP or
785 the vc1 one for WVP2 */
786 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
788 // switch AVCodecContext parameters to those of the sprites
789 avctx->width = avctx->coded_width = v->sprite_width;
790 avctx->height = avctx->coded_height = v->sprite_height;
797 if (s->context_initialized &&
798 (s->width != avctx->coded_width ||
799 s->height != avctx->coded_height)) {
800 ff_vc1_decode_end(avctx);
803 if (!s->context_initialized) {
804 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
806 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
807 ff_mpv_common_end(s);
811 s->low_delay = !avctx->has_b_frames || v->res_sprite;
813 if (v->profile == PROFILE_ADVANCED) {
814 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
815 ret = AVERROR_INVALIDDATA;
818 s->h_edge_pos = avctx->coded_width;
819 s->v_edge_pos = avctx->coded_height;
823 // do parse frame header
824 v->pic_header_flag = 0;
825 v->first_pic_header_flag = 1;
826 if (v->profile < PROFILE_ADVANCED) {
827 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
831 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
835 v->first_pic_header_flag = 0;
837 if (avctx->debug & FF_DEBUG_PICT_INFO)
838 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
840 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
841 && s->pict_type != AV_PICTURE_TYPE_I) {
842 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
843 ret = AVERROR_INVALIDDATA;
847 if ((s->mb_height >> v->field_mode) == 0) {
848 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
849 ret = AVERROR_INVALIDDATA;
853 // for skipping the frame
854 s->current_picture.f->pict_type = s->pict_type;
855 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
857 /* skip B-frames if we don't have reference frames */
858 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
859 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
862 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
863 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
864 avctx->skip_frame >= AVDISCARD_ALL) {
868 if (s->next_p_frame_damaged) {
869 if (s->pict_type == AV_PICTURE_TYPE_B)
872 s->next_p_frame_damaged = 0;
875 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
879 v->s.current_picture_ptr->field_picture = v->field_mode;
880 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
881 v->s.current_picture_ptr->f->top_field_first = v->tff;
883 // process pulldown flags
884 s->current_picture_ptr->f->repeat_pict = 0;
885 // Pulldown flags are only valid when 'broadcast' has been set.
886 // So ticks_per_frame will be 2
889 s->current_picture_ptr->f->repeat_pict = 1;
890 } else if (v->rptfrm) {
892 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
895 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
896 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
898 if (avctx->hwaccel) {
900 if (v->field_mode && buf_start_second_field) {
901 // decode first field
902 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
903 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
905 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
907 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
910 // decode second field
911 s->gb = slices[n_slices1 + 1].gb;
912 s->picture_structure = PICT_TOP_FIELD + v->tff;
914 v->pic_header_flag = 0;
915 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
916 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
917 ret = AVERROR_INVALIDDATA;
920 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
922 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
924 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
926 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
929 s->picture_structure = PICT_FRAME;
930 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
934 // no slices, decode the frame as-is
935 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
938 // decode the frame part as the first slice
939 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
942 // and process the slices as additional slices afterwards
943 for (i = 0 ; i < n_slices; i++) {
944 s->gb = slices[i].gb;
945 s->mb_y = slices[i].mby_start;
947 v->pic_header_flag = get_bits1(&s->gb);
948 if (v->pic_header_flag) {
949 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
950 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
951 ret = AVERROR_INVALIDDATA;
952 if (avctx->err_recognition & AV_EF_EXPLODE)
958 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
962 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
968 ff_mpeg_er_frame_start(s);
970 v->bits = buf_size * 8;
971 v->end_mb_x = s->mb_width;
973 s->current_picture.f->linesize[0] <<= 1;
974 s->current_picture.f->linesize[1] <<= 1;
975 s->current_picture.f->linesize[2] <<= 1;
979 mb_height = s->mb_height >> v->field_mode;
981 av_assert0 (mb_height > 0);
983 for (i = 0; i <= n_slices; i++) {
984 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
985 if (v->field_mode <= 0) {
986 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
987 "picture boundary (%d >= %d)\n", i,
988 slices[i - 1].mby_start, mb_height);
992 av_assert0((s->mb_height & 1) == 0);
993 v->blocks_off = s->b8_stride * (s->mb_height&~1);
994 v->mb_off = s->mb_stride * s->mb_height >> 1;
1001 v->pic_header_flag = 0;
1002 if (v->field_mode && i == n_slices1 + 2) {
1003 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1004 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1005 ret = AVERROR_INVALIDDATA;
1006 if (avctx->err_recognition & AV_EF_EXPLODE)
1010 } else if (get_bits1(&s->gb)) {
1011 v->pic_header_flag = 1;
1012 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1013 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1014 ret = AVERROR_INVALIDDATA;
1015 if (avctx->err_recognition & AV_EF_EXPLODE)
1023 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1024 if (!v->field_mode || v->second_field)
1025 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1027 if (i >= n_slices) {
1028 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1031 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1033 if (s->end_mb_y <= s->start_mb_y) {
1034 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1037 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1038 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1041 ff_vc1_decode_blocks(v);
1043 s->gb = slices[i].gb;
1045 if (v->field_mode) {
1046 v->second_field = 0;
1047 s->current_picture.f->linesize[0] >>= 1;
1048 s->current_picture.f->linesize[1] >>= 1;
1049 s->current_picture.f->linesize[2] >>= 1;
1051 s->uvlinesize >>= 1;
1052 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1053 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1054 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1057 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1058 get_bits_count(&s->gb), s->gb.size_in_bits);
1059 // if (get_bits_count(&s->gb) > buf_size * 8)
1061 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1062 ret = AVERROR_INVALIDDATA;
1066 ff_er_frame_end(&s->er);
1069 ff_mpv_frame_end(s);
1071 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1073 avctx->width = avctx->coded_width = v->output_width;
1074 avctx->height = avctx->coded_height = v->output_height;
1075 if (avctx->skip_frame >= AVDISCARD_NONREF)
1077 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1078 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1081 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1085 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1086 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1088 ff_print_debug_info(s, s->current_picture_ptr, pict);
1090 } else if (s->last_picture_ptr) {
1091 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1093 ff_print_debug_info(s, s->last_picture_ptr, pict);
1100 for (i = 0; i < n_slices; i++)
1101 av_free(slices[i].buf);
1107 for (i = 0; i < n_slices; i++)
1108 av_free(slices[i].buf);
1114 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1115 #if CONFIG_VC1_DXVA2_HWACCEL
1116 AV_PIX_FMT_DXVA2_VLD,
1118 #if CONFIG_VC1_D3D11VA_HWACCEL
1119 AV_PIX_FMT_D3D11VA_VLD,
1122 #if CONFIG_VC1_VAAPI_HWACCEL
1125 #if CONFIG_VC1_VDPAU_HWACCEL
1132 AVCodec ff_vc1_decoder = {
1134 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1135 .type = AVMEDIA_TYPE_VIDEO,
1136 .id = AV_CODEC_ID_VC1,
1137 .priv_data_size = sizeof(VC1Context),
1138 .init = vc1_decode_init,
1139 .close = ff_vc1_decode_end,
1140 .decode = vc1_decode_frame,
1141 .flush = ff_mpeg_flush,
1142 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1143 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1144 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1147 #if CONFIG_WMV3_DECODER
1148 AVCodec ff_wmv3_decoder = {
1150 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1151 .type = AVMEDIA_TYPE_VIDEO,
1152 .id = AV_CODEC_ID_WMV3,
1153 .priv_data_size = sizeof(VC1Context),
1154 .init = vc1_decode_init,
1155 .close = ff_vc1_decode_end,
1156 .decode = vc1_decode_frame,
1157 .flush = ff_mpeg_flush,
1158 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1159 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1160 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1164 #if CONFIG_WMV3IMAGE_DECODER
1165 AVCodec ff_wmv3image_decoder = {
1166 .name = "wmv3image",
1167 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1168 .type = AVMEDIA_TYPE_VIDEO,
1169 .id = AV_CODEC_ID_WMV3IMAGE,
1170 .priv_data_size = sizeof(VC1Context),
1171 .init = vc1_decode_init,
1172 .close = ff_vc1_decode_end,
1173 .decode = vc1_decode_frame,
1174 .capabilities = AV_CODEC_CAP_DR1,
1175 .flush = vc1_sprite_flush,
1176 .pix_fmts = (const enum AVPixelFormat[]) {
1183 #if CONFIG_VC1IMAGE_DECODER
1184 AVCodec ff_vc1image_decoder = {
1186 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1187 .type = AVMEDIA_TYPE_VIDEO,
1188 .id = AV_CODEC_ID_VC1IMAGE,
1189 .priv_data_size = sizeof(VC1Context),
1190 .init = vc1_decode_init,
1191 .close = ff_vc1_decode_end,
1192 .decode = vc1_decode_frame,
1193 .capabilities = AV_CODEC_CAP_DR1,
1194 .flush = vc1_sprite_flush,
1195 .pix_fmts = (const enum AVPixelFormat[]) {