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"
39 #include "vdpau_compat.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;
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);
337 v->n_allocated_blks = s->mb_width + 2;
338 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
339 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
340 v->cbp = v->cbp_base + s->mb_stride;
341 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
342 v->ttblk = v->ttblk_base + s->mb_stride;
343 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
344 v->is_intra = v->is_intra_base + s->mb_stride;
345 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
346 v->luma_mv = v->luma_mv_base + s->mb_stride;
348 /* allocate block type info in that way so it could be used with s->block_index[] */
349 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
350 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
351 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
352 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
354 /* allocate memory to store block level MV info */
355 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
356 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
357 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
358 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
359 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
360 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
361 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
362 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
364 /* Init coded blocks info */
365 if (v->profile == PROFILE_ADVANCED) {
366 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
368 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
372 ff_intrax8_common_init(&v->x8,s);
374 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
375 for (i = 0; i < 4; i++)
376 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
377 return AVERROR(ENOMEM);
380 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
381 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
383 av_freep(&v->mv_type_mb_plane);
384 av_freep(&v->direct_mb_plane);
385 av_freep(&v->acpred_plane);
386 av_freep(&v->over_flags_plane);
388 av_freep(&v->cbp_base);
389 av_freep(&v->ttblk_base);
390 av_freep(&v->is_intra_base);
391 av_freep(&v->luma_mv_base);
392 av_freep(&v->mb_type_base);
393 return AVERROR(ENOMEM);
399 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
402 for (i = 0; i < 64; i++) {
403 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
404 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
405 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
406 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
407 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
408 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
414 /** Initialize a VC1/WMV3 decoder
415 * @todo TODO: Handle VC-1 IDUs (Transport level?)
416 * @todo TODO: Decypher remaining bits in extra_data
418 static av_cold int vc1_decode_init(AVCodecContext *avctx)
420 VC1Context *v = avctx->priv_data;
421 MpegEncContext *s = &v->s;
425 /* save the container output size for WMImage */
426 v->output_width = avctx->width;
427 v->output_height = avctx->height;
429 if (!avctx->extradata_size || !avctx->extradata)
431 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
432 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
434 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
435 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
436 avctx->color_range = AVCOL_RANGE_MPEG;
440 if ((ret = ff_vc1_init_common(v)) < 0)
442 // ensure static VLC tables are initialized
443 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
445 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
447 // Hack to ensure the above functions will be called
448 // again once we know all necessary settings.
449 // That this is necessary might indicate a bug.
450 ff_vc1_decode_end(avctx);
452 ff_blockdsp_init(&s->bdsp, avctx);
453 ff_h264chroma_init(&v->h264chroma, 8);
454 ff_qpeldsp_init(&s->qdsp);
456 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
459 // looks like WMV3 has a sequence header stored in the extradata
460 // advanced sequence header may be before the first frame
461 // the last byte of the extradata is a version number, 1 for the
462 // samples we can decode
464 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
466 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
469 count = avctx->extradata_size*8 - get_bits_count(&gb);
471 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
472 count, get_bits_long(&gb, FFMIN(count, 32)));
473 } else if (count < 0) {
474 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
476 } else { // VC1/WVC1/WVP2
477 const uint8_t *start = avctx->extradata;
478 uint8_t *end = avctx->extradata + avctx->extradata_size;
481 uint8_t *buf2 = NULL;
482 int seq_initialized = 0, ep_initialized = 0;
484 if (avctx->extradata_size < 16) {
485 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
489 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
491 return AVERROR(ENOMEM);
493 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
495 for (; next < end; start = next) {
496 next = find_next_marker(start + 4, end);
497 size = next - start - 4;
500 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
501 init_get_bits(&gb, buf2, buf2_size * 8);
502 switch (AV_RB32(start)) {
503 case VC1_CODE_SEQHDR:
504 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
510 case VC1_CODE_ENTRYPOINT:
511 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
520 if (!seq_initialized || !ep_initialized) {
521 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
524 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
527 v->sprite_output_frame = av_frame_alloc();
528 if (!v->sprite_output_frame)
529 return AVERROR(ENOMEM);
531 avctx->profile = v->profile;
532 if (v->profile == PROFILE_ADVANCED)
533 avctx->level = v->level;
535 avctx->has_b_frames = !!avctx->max_b_frames;
537 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
538 avctx->color_primaries = v->color_prim;
539 if (v->transfer_char == 1 || v->transfer_char == 7)
540 avctx->color_trc = v->transfer_char;
541 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
542 avctx->colorspace = v->matrix_coef;
544 s->mb_width = (avctx->coded_width + 15) >> 4;
545 s->mb_height = (avctx->coded_height + 15) >> 4;
547 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
548 ff_vc1_init_transposed_scantables(v);
550 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
555 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
556 v->sprite_width = avctx->coded_width;
557 v->sprite_height = avctx->coded_height;
559 avctx->coded_width = avctx->width = v->output_width;
560 avctx->coded_height = avctx->height = v->output_height;
562 // prevent 16.16 overflows
563 if (v->sprite_width > 1 << 14 ||
564 v->sprite_height > 1 << 14 ||
565 v->output_width > 1 << 14 ||
566 v->output_height > 1 << 14) return -1;
568 if ((v->sprite_width&1) || (v->sprite_height&1)) {
569 avpriv_request_sample(avctx, "odd sprites support");
570 return AVERROR_PATCHWELCOME;
576 /** Close a VC1/WMV3 decoder
577 * @warning Initial try at using MpegEncContext stuff
579 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
581 VC1Context *v = avctx->priv_data;
584 av_frame_free(&v->sprite_output_frame);
586 for (i = 0; i < 4; i++)
587 av_freep(&v->sr_rows[i >> 1][i & 1]);
588 av_freep(&v->hrd_rate);
589 av_freep(&v->hrd_buffer);
590 ff_mpv_common_end(&v->s);
591 av_freep(&v->mv_type_mb_plane);
592 av_freep(&v->direct_mb_plane);
593 av_freep(&v->forward_mb_plane);
594 av_freep(&v->fieldtx_plane);
595 av_freep(&v->acpred_plane);
596 av_freep(&v->over_flags_plane);
597 av_freep(&v->mb_type_base);
598 av_freep(&v->blk_mv_type_base);
599 av_freep(&v->mv_f_base);
600 av_freep(&v->mv_f_next_base);
602 av_freep(&v->cbp_base);
603 av_freep(&v->ttblk_base);
604 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
605 av_freep(&v->luma_mv_base);
606 ff_intrax8_common_end(&v->x8);
611 /** Decode a VC1/WMV3 frame
612 * @todo TODO: Handle VC-1 IDUs (Transport level?)
614 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
615 int *got_frame, AVPacket *avpkt)
617 const uint8_t *buf = avpkt->data;
618 int buf_size = avpkt->size, n_slices = 0, i, ret;
619 VC1Context *v = avctx->priv_data;
620 MpegEncContext *s = &v->s;
621 AVFrame *pict = data;
622 uint8_t *buf2 = NULL;
623 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
624 int mb_height, n_slices1=-1;
629 } *slices = NULL, *tmp;
633 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
636 /* no supplementary picture */
637 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
638 /* special case for last picture */
639 if (s->low_delay == 0 && s->next_picture_ptr) {
640 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
642 s->next_picture_ptr = NULL;
651 if (s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
652 if (v->profile < PROFILE_ADVANCED)
653 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
655 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
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 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
683 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
685 case VC1_CODE_FIELD: {
689 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
692 buf_start_second_field = start;
693 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
695 ret = AVERROR(ENOMEM);
699 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
700 if (!slices[n_slices].buf) {
701 ret = AVERROR(ENOMEM);
704 buf_size3 = vc1_unescape_buffer(start + 4, size,
705 slices[n_slices].buf);
706 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
708 /* assuming that the field marker is at the exact middle,
710 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
711 n_slices1 = n_slices - 1; // index of the last slice of the first field
715 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
716 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
717 init_get_bits(&s->gb, buf2, buf_size2 * 8);
718 ff_vc1_decode_entry_point(avctx, v, &s->gb);
720 case VC1_CODE_SLICE: {
722 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
724 ret = AVERROR(ENOMEM);
728 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
729 if (!slices[n_slices].buf) {
730 ret = AVERROR(ENOMEM);
733 buf_size3 = vc1_unescape_buffer(start + 4, size,
734 slices[n_slices].buf);
735 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
737 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
743 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
744 const uint8_t *divider;
747 divider = find_next_marker(buf, buf + buf_size);
748 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
749 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
750 ret = AVERROR_INVALIDDATA;
752 } else { // found field marker, unescape second field
755 || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
758 buf_start_second_field = divider;
759 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
761 ret = AVERROR(ENOMEM);
765 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
766 if (!slices[n_slices].buf) {
767 ret = AVERROR(ENOMEM);
770 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
771 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
773 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
774 n_slices1 = n_slices - 1;
777 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
779 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
781 init_get_bits(&s->gb, buf2, buf_size2*8);
783 init_get_bits(&s->gb, buf, buf_size*8);
786 v->new_sprite = !get_bits1(&s->gb);
787 v->two_sprites = get_bits1(&s->gb);
788 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
789 we're using the sprite compositor. These are intentionally kept separate
790 so you can get the raw sprites by using the wmv3 decoder for WMVP or
791 the vc1 one for WVP2 */
792 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
794 // switch AVCodecContext parameters to those of the sprites
795 avctx->width = avctx->coded_width = v->sprite_width;
796 avctx->height = avctx->coded_height = v->sprite_height;
803 if (s->context_initialized &&
804 (s->width != avctx->coded_width ||
805 s->height != avctx->coded_height)) {
806 ff_vc1_decode_end(avctx);
809 if (!s->context_initialized) {
810 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
812 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
813 ff_mpv_common_end(s);
817 s->low_delay = !avctx->has_b_frames || v->res_sprite;
819 if (v->profile == PROFILE_ADVANCED) {
820 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
821 ret = AVERROR_INVALIDDATA;
824 s->h_edge_pos = avctx->coded_width;
825 s->v_edge_pos = avctx->coded_height;
829 // do parse frame header
830 v->pic_header_flag = 0;
831 v->first_pic_header_flag = 1;
832 if (v->profile < PROFILE_ADVANCED) {
833 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
837 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
841 v->first_pic_header_flag = 0;
843 if (avctx->debug & FF_DEBUG_PICT_INFO)
844 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
846 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
847 && s->pict_type != AV_PICTURE_TYPE_I) {
848 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
849 ret = AVERROR_INVALIDDATA;
853 if ((s->mb_height >> v->field_mode) == 0) {
854 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
855 ret = AVERROR_INVALIDDATA;
859 // for skipping the frame
860 s->current_picture.f->pict_type = s->pict_type;
861 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
863 /* skip B-frames if we don't have reference frames */
864 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
865 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
868 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
869 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
870 avctx->skip_frame >= AVDISCARD_ALL) {
874 if (s->next_p_frame_damaged) {
875 if (s->pict_type == AV_PICTURE_TYPE_B)
878 s->next_p_frame_damaged = 0;
881 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
885 v->s.current_picture_ptr->field_picture = v->field_mode;
886 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
887 v->s.current_picture_ptr->f->top_field_first = v->tff;
889 // process pulldown flags
890 s->current_picture_ptr->f->repeat_pict = 0;
891 // Pulldown flags are only valid when 'broadcast' has been set.
892 // So ticks_per_frame will be 2
895 s->current_picture_ptr->f->repeat_pict = 1;
896 } else if (v->rptfrm) {
898 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
901 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
902 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
905 if ((CONFIG_VC1_VDPAU_DECODER)
906 &&s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
907 if (v->field_mode && buf_start_second_field) {
908 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
909 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
911 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
915 if (avctx->hwaccel) {
916 if (v->field_mode && buf_start_second_field) {
917 // decode first field
918 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
919 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
921 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
923 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
926 // decode second field
927 s->gb = slices[n_slices1 + 1].gb;
928 s->picture_structure = PICT_TOP_FIELD + v->tff;
930 v->pic_header_flag = 0;
931 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
932 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
933 ret = AVERROR_INVALIDDATA;
936 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
938 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
940 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
942 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
945 s->picture_structure = PICT_FRAME;
946 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
948 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
950 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
956 ff_mpeg_er_frame_start(s);
958 v->bits = buf_size * 8;
959 v->end_mb_x = s->mb_width;
961 s->current_picture.f->linesize[0] <<= 1;
962 s->current_picture.f->linesize[1] <<= 1;
963 s->current_picture.f->linesize[2] <<= 1;
967 mb_height = s->mb_height >> v->field_mode;
969 av_assert0 (mb_height > 0);
971 for (i = 0; i <= n_slices; i++) {
972 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
973 if (v->field_mode <= 0) {
974 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
975 "picture boundary (%d >= %d)\n", i,
976 slices[i - 1].mby_start, mb_height);
980 av_assert0((s->mb_height & 1) == 0);
981 v->blocks_off = s->b8_stride * (s->mb_height&~1);
982 v->mb_off = s->mb_stride * s->mb_height >> 1;
989 v->pic_header_flag = 0;
990 if (v->field_mode && i == n_slices1 + 2) {
991 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
992 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
993 ret = AVERROR_INVALIDDATA;
994 if (avctx->err_recognition & AV_EF_EXPLODE)
998 } else if (get_bits1(&s->gb)) {
999 v->pic_header_flag = 1;
1000 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1001 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1002 ret = AVERROR_INVALIDDATA;
1003 if (avctx->err_recognition & AV_EF_EXPLODE)
1011 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1012 if (!v->field_mode || v->second_field)
1013 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1015 if (i >= n_slices) {
1016 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1019 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1021 if (s->end_mb_y <= s->start_mb_y) {
1022 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1025 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1026 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1029 ff_vc1_decode_blocks(v);
1031 s->gb = slices[i].gb;
1033 if (v->field_mode) {
1034 v->second_field = 0;
1035 s->current_picture.f->linesize[0] >>= 1;
1036 s->current_picture.f->linesize[1] >>= 1;
1037 s->current_picture.f->linesize[2] >>= 1;
1039 s->uvlinesize >>= 1;
1040 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1041 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1042 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1045 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1046 get_bits_count(&s->gb), s->gb.size_in_bits);
1047 // if (get_bits_count(&s->gb) > buf_size * 8)
1049 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1050 ret = AVERROR_INVALIDDATA;
1054 ff_er_frame_end(&s->er);
1057 ff_mpv_frame_end(s);
1059 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1061 avctx->width = avctx->coded_width = v->output_width;
1062 avctx->height = avctx->coded_height = v->output_height;
1063 if (avctx->skip_frame >= AVDISCARD_NONREF)
1065 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1066 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1069 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1073 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1074 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1076 ff_print_debug_info(s, s->current_picture_ptr, pict);
1078 } else if (s->last_picture_ptr) {
1079 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1081 ff_print_debug_info(s, s->last_picture_ptr, pict);
1088 for (i = 0; i < n_slices; i++)
1089 av_free(slices[i].buf);
1095 for (i = 0; i < n_slices; i++)
1096 av_free(slices[i].buf);
1102 static const AVProfile profiles[] = {
1103 { FF_PROFILE_VC1_SIMPLE, "Simple" },
1104 { FF_PROFILE_VC1_MAIN, "Main" },
1105 { FF_PROFILE_VC1_COMPLEX, "Complex" },
1106 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
1107 { FF_PROFILE_UNKNOWN },
1110 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1111 #if CONFIG_VC1_DXVA2_HWACCEL
1112 AV_PIX_FMT_DXVA2_VLD,
1114 #if CONFIG_VC1_D3D11VA_HWACCEL
1115 AV_PIX_FMT_D3D11VA_VLD,
1117 #if CONFIG_VC1_VAAPI_HWACCEL
1120 #if CONFIG_VC1_VDPAU_HWACCEL
1127 AVCodec ff_vc1_decoder = {
1129 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1130 .type = AVMEDIA_TYPE_VIDEO,
1131 .id = AV_CODEC_ID_VC1,
1132 .priv_data_size = sizeof(VC1Context),
1133 .init = vc1_decode_init,
1134 .close = ff_vc1_decode_end,
1135 .decode = vc1_decode_frame,
1136 .flush = ff_mpeg_flush,
1137 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1138 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1139 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1142 #if CONFIG_WMV3_DECODER
1143 AVCodec ff_wmv3_decoder = {
1145 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1146 .type = AVMEDIA_TYPE_VIDEO,
1147 .id = AV_CODEC_ID_WMV3,
1148 .priv_data_size = sizeof(VC1Context),
1149 .init = vc1_decode_init,
1150 .close = ff_vc1_decode_end,
1151 .decode = vc1_decode_frame,
1152 .flush = ff_mpeg_flush,
1153 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1154 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1155 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1159 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1160 AVCodec ff_wmv3_vdpau_decoder = {
1161 .name = "wmv3_vdpau",
1162 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1163 .type = AVMEDIA_TYPE_VIDEO,
1164 .id = AV_CODEC_ID_WMV3,
1165 .priv_data_size = sizeof(VC1Context),
1166 .init = vc1_decode_init,
1167 .close = ff_vc1_decode_end,
1168 .decode = vc1_decode_frame,
1169 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1170 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1171 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1175 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1176 AVCodec ff_vc1_vdpau_decoder = {
1177 .name = "vc1_vdpau",
1178 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1179 .type = AVMEDIA_TYPE_VIDEO,
1180 .id = AV_CODEC_ID_VC1,
1181 .priv_data_size = sizeof(VC1Context),
1182 .init = vc1_decode_init,
1183 .close = ff_vc1_decode_end,
1184 .decode = vc1_decode_frame,
1185 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1186 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1187 .profiles = NULL_IF_CONFIG_SMALL(profiles)
1191 #if CONFIG_WMV3IMAGE_DECODER
1192 AVCodec ff_wmv3image_decoder = {
1193 .name = "wmv3image",
1194 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1195 .type = AVMEDIA_TYPE_VIDEO,
1196 .id = AV_CODEC_ID_WMV3IMAGE,
1197 .priv_data_size = sizeof(VC1Context),
1198 .init = vc1_decode_init,
1199 .close = ff_vc1_decode_end,
1200 .decode = vc1_decode_frame,
1201 .capabilities = AV_CODEC_CAP_DR1,
1202 .flush = vc1_sprite_flush,
1203 .pix_fmts = (const enum AVPixelFormat[]) {
1210 #if CONFIG_VC1IMAGE_DECODER
1211 AVCodec ff_vc1image_decoder = {
1213 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1214 .type = AVMEDIA_TYPE_VIDEO,
1215 .id = AV_CODEC_ID_VC1IMAGE,
1216 .priv_data_size = sizeof(VC1Context),
1217 .init = vc1_decode_init,
1218 .close = ff_vc1_decode_end,
1219 .decode = vc1_decode_frame,
1220 .capabilities = AV_CODEC_CAP_DR1,
1221 .flush = vc1_sprite_flush,
1222 .pix_fmts = (const enum AVPixelFormat[]) {