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 Libav.
9 * Libav 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 * Libav 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 Libav; 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"
41 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
43 typedef struct SpriteData {
45 * Transform coefficients for both sprites in 16.16 fixed point format,
46 * in the order they appear in the bitstream:
57 int effect_type, effect_flag;
58 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
59 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
62 static inline int get_fp_val(GetBitContext* gb)
64 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
67 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
71 switch (get_bits(gb, 2)) {
74 c[2] = get_fp_val(gb);
78 c[0] = c[4] = get_fp_val(gb);
79 c[2] = get_fp_val(gb);
82 c[0] = get_fp_val(gb);
83 c[2] = get_fp_val(gb);
84 c[4] = get_fp_val(gb);
87 c[0] = get_fp_val(gb);
88 c[1] = get_fp_val(gb);
89 c[2] = get_fp_val(gb);
90 c[3] = get_fp_val(gb);
91 c[4] = get_fp_val(gb);
94 c[5] = get_fp_val(gb);
96 c[6] = get_fp_val(gb);
101 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
103 AVCodecContext *avctx = v->s.avctx;
106 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
107 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
108 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
109 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
110 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
111 for (i = 0; i < 7; i++)
112 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
113 sd->coefs[sprite][i] / (1<<16),
114 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
115 av_log(avctx, AV_LOG_DEBUG, "\n");
119 if (sd->effect_type = get_bits_long(gb, 30)) {
120 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
122 vc1_sprite_parse_transform(gb, sd->effect_params1);
125 vc1_sprite_parse_transform(gb, sd->effect_params1);
126 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
129 for (i = 0; i < sd->effect_pcount1; i++)
130 sd->effect_params1[i] = get_fp_val(gb);
132 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
133 // effect 13 is simple alpha blending and matches the opacity above
134 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
135 for (i = 0; i < sd->effect_pcount1; i++)
136 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
137 sd->effect_params1[i] / (1 << 16),
138 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
139 av_log(avctx, AV_LOG_DEBUG, "\n");
142 sd->effect_pcount2 = get_bits(gb, 16);
143 if (sd->effect_pcount2 > 10) {
144 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
146 } else if (sd->effect_pcount2) {
148 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
149 while (++i < sd->effect_pcount2) {
150 sd->effect_params2[i] = get_fp_val(gb);
151 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
152 sd->effect_params2[i] / (1 << 16),
153 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
155 av_log(avctx, AV_LOG_DEBUG, "\n");
158 if (sd->effect_flag = get_bits1(gb))
159 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
161 if (get_bits_count(gb) >= gb->size_in_bits +
162 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
163 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
164 if (get_bits_count(gb) < gb->size_in_bits - 8)
165 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
168 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
170 int i, plane, row, sprite;
171 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
172 uint8_t* src_h[2][2];
173 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
175 MpegEncContext *s = &v->s;
177 for (i = 0; i < 2; i++) {
178 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
179 xadv[i] = sd->coefs[i][0];
180 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
181 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
183 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
184 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
186 alpha = av_clip_uint16(sd->coefs[1][6]);
188 for (plane = 0; plane < (s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
189 int width = v->output_width>>!!plane;
191 for (row = 0; row < v->output_height>>!!plane; row++) {
192 uint8_t *dst = v->sprite_output_frame->data[plane] +
193 v->sprite_output_frame->linesize[plane] * row;
195 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
196 uint8_t *iplane = s->current_picture.f->data[plane];
197 int iline = s->current_picture.f->linesize[plane];
198 int ycoord = yoff[sprite] + yadv[sprite] * row;
199 int yline = ycoord >> 16;
201 ysub[sprite] = ycoord & 0xFFFF;
203 iplane = s->last_picture.f->data[plane];
204 iline = s->last_picture.f->linesize[plane];
206 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
207 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
208 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
210 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
212 if (sr_cache[sprite][0] != yline) {
213 if (sr_cache[sprite][1] == yline) {
214 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
215 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
217 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
218 sr_cache[sprite][0] = yline;
221 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
222 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
223 iplane + next_line, xoff[sprite],
224 xadv[sprite], width);
225 sr_cache[sprite][1] = yline + 1;
227 src_h[sprite][0] = v->sr_rows[sprite][0];
228 src_h[sprite][1] = v->sr_rows[sprite][1];
232 if (!v->two_sprites) {
234 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
236 memcpy(dst, src_h[0][0], width);
239 if (ysub[0] && ysub[1]) {
240 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
241 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
242 } else if (ysub[0]) {
243 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
244 src_h[1][0], alpha, width);
245 } else if (ysub[1]) {
246 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
247 src_h[0][0], (1<<16)-1-alpha, width);
249 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
255 for (i = 0; i < 2; i++) {
265 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
267 MpegEncContext *s = &v->s;
268 AVCodecContext *avctx = s->avctx;
271 vc1_parse_sprites(v, gb, &sd);
273 if (!s->current_picture.f->data[0]) {
274 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
278 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
279 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
283 av_frame_unref(v->sprite_output_frame);
284 if (ff_get_buffer(avctx, v->sprite_output_frame, 0) < 0) {
285 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
289 vc1_draw_sprites(v, &sd);
294 static void vc1_sprite_flush(AVCodecContext *avctx)
296 VC1Context *v = avctx->priv_data;
297 MpegEncContext *s = &v->s;
298 AVFrame *f = s->current_picture.f;
301 /* Windows Media Image codecs have a convergence interval of two keyframes.
302 Since we can't enforce it, clear to black the missing sprite. This is
303 wrong but it looks better than doing nothing. */
306 for (plane = 0; plane < (s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
307 for (i = 0; i < v->sprite_height>>!!plane; i++)
308 memset(f->data[plane] + i * f->linesize[plane],
309 plane ? 128 : 0, f->linesize[plane]);
314 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
316 MpegEncContext *s = &v->s;
317 int i, ret = AVERROR(ENOMEM);
318 int mb_height = FFALIGN(s->mb_height, 2);
320 /* Allocate mb bitplanes */
321 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
322 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
323 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
324 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
325 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
326 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
327 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
328 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
331 v->n_allocated_blks = s->mb_width + 2;
332 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
333 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
334 if (!v->block || !v->cbp_base)
336 v->cbp = v->cbp_base + s->mb_stride;
337 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
340 v->ttblk = v->ttblk_base + s->mb_stride;
341 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
342 if (!v->is_intra_base)
344 v->is_intra = v->is_intra_base + s->mb_stride;
345 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
346 if (!v->luma_mv_base)
348 v->luma_mv = v->luma_mv_base + s->mb_stride;
350 /* allocate block type info in that way so it could be used with s->block_index[] */
351 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
352 if (!v->mb_type_base)
354 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
355 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
356 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
358 /* allocate memory to store block level MV info */
359 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
360 if (!v->blk_mv_type_base)
362 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
363 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
366 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
367 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
368 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
369 if (!v->mv_f_next_base)
371 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
372 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
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 v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width);
377 if (!v->sr_rows[i >> 1][i & 1])
382 ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp,
383 s->block, s->block_last_index,
384 s->mb_width, s->mb_height);
391 ff_vc1_decode_end(s->avctx);
395 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
398 for (i = 0; i < 64; i++) {
399 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
400 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
401 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
402 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
403 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
404 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
410 /** Initialize a VC1/WMV3 decoder
411 * @todo TODO: Handle VC-1 IDUs (Transport level?)
412 * @todo TODO: Decipher remaining bits in extra_data
414 static av_cold int vc1_decode_init(AVCodecContext *avctx)
416 VC1Context *v = avctx->priv_data;
417 MpegEncContext *s = &v->s;
420 /* save the container output size for WMImage */
421 v->output_width = avctx->width;
422 v->output_height = avctx->height;
424 if (!avctx->extradata_size || !avctx->extradata)
426 if (!(avctx->flags & AV_CODEC_FLAG_GRAY))
427 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
429 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
432 if (ff_vc1_init_common(v) < 0)
434 ff_blockdsp_init(&s->bdsp);
435 ff_h264chroma_init(&v->h264chroma, 8);
436 ff_qpeldsp_init(&s->qdsp);
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 (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);
472 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
474 for (; next < end; start = next) {
475 next = find_next_marker(start + 4, end);
476 size = next - start - 4;
479 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
480 init_get_bits(&gb, buf2, buf2_size * 8);
481 switch (AV_RB32(start)) {
482 case VC1_CODE_SEQHDR:
483 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
489 case VC1_CODE_ENTRYPOINT:
490 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
499 if (!seq_initialized || !ep_initialized) {
500 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
503 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
506 v->sprite_output_frame = av_frame_alloc();
507 if (!v->sprite_output_frame)
508 return AVERROR(ENOMEM);
510 avctx->profile = v->profile;
511 if (v->profile == PROFILE_ADVANCED)
512 avctx->level = v->level;
514 avctx->has_b_frames = !!avctx->max_b_frames;
516 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
517 avctx->color_primaries = v->color_prim;
518 if (v->transfer_char == 1 || v->transfer_char == 7)
519 avctx->color_trc = v->transfer_char;
520 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
521 avctx->colorspace = v->matrix_coef;
523 s->mb_width = (avctx->coded_width + 15) >> 4;
524 s->mb_height = (avctx->coded_height + 15) >> 4;
526 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
527 ff_vc1_init_transposed_scantables(v);
529 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
534 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
535 v->sprite_width = avctx->coded_width;
536 v->sprite_height = avctx->coded_height;
538 avctx->coded_width = avctx->width = v->output_width;
539 avctx->coded_height = avctx->height = v->output_height;
541 // prevent 16.16 overflows
542 if (v->sprite_width > 1 << 14 ||
543 v->sprite_height > 1 << 14 ||
544 v->output_width > 1 << 14 ||
545 v->output_height > 1 << 14) return -1;
550 /** Close a VC1/WMV3 decoder
551 * @warning Initial try at using MpegEncContext stuff
553 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
555 VC1Context *v = avctx->priv_data;
558 av_frame_free(&v->sprite_output_frame);
560 for (i = 0; i < 4; i++)
561 av_freep(&v->sr_rows[i >> 1][i & 1]);
562 av_freep(&v->hrd_rate);
563 av_freep(&v->hrd_buffer);
564 ff_mpv_common_end(&v->s);
565 av_freep(&v->mv_type_mb_plane);
566 av_freep(&v->direct_mb_plane);
567 av_freep(&v->forward_mb_plane);
568 av_freep(&v->fieldtx_plane);
569 av_freep(&v->acpred_plane);
570 av_freep(&v->over_flags_plane);
571 av_freep(&v->mb_type_base);
572 av_freep(&v->blk_mv_type_base);
573 av_freep(&v->mv_f_base);
574 av_freep(&v->mv_f_next_base);
576 av_freep(&v->cbp_base);
577 av_freep(&v->ttblk_base);
578 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
579 av_freep(&v->luma_mv_base);
580 ff_intrax8_common_end(&v->x8);
585 /** Decode a VC1/WMV3 frame
586 * @todo TODO: Handle VC-1 IDUs (Transport level?)
588 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
589 int *got_frame, AVPacket *avpkt)
591 const uint8_t *buf = avpkt->data;
592 int buf_size = avpkt->size, n_slices = 0, i, ret;
593 VC1Context *v = avctx->priv_data;
594 MpegEncContext *s = &v->s;
595 AVFrame *pict = data;
596 uint8_t *buf2 = NULL;
597 const uint8_t *buf_start = buf;
598 int mb_height, n_slices1;
603 } *slices = NULL, *tmp;
605 /* no supplementary picture */
606 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
607 /* special case for last picture */
608 if (s->low_delay == 0 && s->next_picture_ptr) {
609 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
611 s->next_picture_ptr = NULL;
619 //for advanced profile we may need to parse and unescape data
620 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
622 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
624 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
625 const uint8_t *start, *end, *next;
629 for (start = buf, end = buf + buf_size; next < end; start = next) {
630 next = find_next_marker(start + 4, end);
631 size = next - start - 4;
632 if (size <= 0) continue;
633 switch (AV_RB32(start)) {
637 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
639 case VC1_CODE_FIELD: {
641 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
645 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
646 if (!slices[n_slices].buf)
648 buf_size3 = vc1_unescape_buffer(start + 4, size,
649 slices[n_slices].buf);
650 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
652 /* assuming that the field marker is at the exact middle,
654 slices[n_slices].mby_start = s->mb_height >> 1;
655 n_slices1 = n_slices - 1; // index of the last slice of the first field
659 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
660 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
661 init_get_bits(&s->gb, buf2, buf_size2 * 8);
662 ff_vc1_decode_entry_point(avctx, v, &s->gb);
664 case VC1_CODE_SLICE: {
666 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
670 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
671 if (!slices[n_slices].buf)
673 buf_size3 = vc1_unescape_buffer(start + 4, size,
674 slices[n_slices].buf);
675 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
677 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
683 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
684 const uint8_t *divider;
687 divider = find_next_marker(buf, buf + buf_size);
688 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
689 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
691 } else { // found field marker, unescape second field
692 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
696 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
697 if (!slices[n_slices].buf)
699 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
700 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
702 slices[n_slices].mby_start = s->mb_height >> 1;
703 n_slices1 = n_slices - 1;
706 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
708 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
710 init_get_bits(&s->gb, buf2, buf_size2*8);
712 init_get_bits(&s->gb, buf, buf_size*8);
715 v->new_sprite = !get_bits1(&s->gb);
716 v->two_sprites = get_bits1(&s->gb);
717 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
718 we're using the sprite compositor. These are intentionally kept separate
719 so you can get the raw sprites by using the wmv3 decoder for WMVP or
720 the vc1 one for WVP2 */
721 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
723 // switch AVCodecContext parameters to those of the sprites
724 avctx->width = avctx->coded_width = v->sprite_width;
725 avctx->height = avctx->coded_height = v->sprite_height;
732 if (s->context_initialized &&
733 (s->width != avctx->coded_width ||
734 s->height != avctx->coded_height)) {
735 ff_vc1_decode_end(avctx);
738 if (!s->context_initialized) {
739 if (ff_msmpeg4_decode_init(avctx) < 0)
741 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
742 ff_mpv_common_end(s);
746 s->low_delay = !avctx->has_b_frames || v->res_sprite;
748 if (v->profile == PROFILE_ADVANCED) {
749 s->h_edge_pos = avctx->coded_width;
750 s->v_edge_pos = avctx->coded_height;
754 // do parse frame header
755 v->pic_header_flag = 0;
756 v->first_pic_header_flag = 1;
757 if (v->profile < PROFILE_ADVANCED) {
758 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
762 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
766 v->first_pic_header_flag = 0;
768 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
769 && s->pict_type != AV_PICTURE_TYPE_I) {
770 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
774 // for skipping the frame
775 s->current_picture.f->pict_type = s->pict_type;
776 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
778 /* skip B-frames if we don't have reference frames */
779 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
782 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
783 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
784 avctx->skip_frame >= AVDISCARD_ALL) {
788 if (s->next_p_frame_damaged) {
789 if (s->pict_type == AV_PICTURE_TYPE_B)
792 s->next_p_frame_damaged = 0;
795 if (ff_mpv_frame_start(s, avctx) < 0) {
799 // process pulldown flags
800 s->current_picture_ptr->f->repeat_pict = 0;
801 // Pulldown flags are only valid when 'broadcast' has been set.
802 // So ticks_per_frame will be 2
805 s->current_picture_ptr->f->repeat_pict = 1;
806 } else if (v->rptfrm) {
808 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
811 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
812 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
814 if (avctx->hwaccel) {
815 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
817 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
819 if (avctx->hwaccel->end_frame(avctx) < 0)
824 ff_mpeg_er_frame_start(s);
826 v->bits = buf_size * 8;
827 v->end_mb_x = s->mb_width;
829 s->current_picture.f->linesize[0] <<= 1;
830 s->current_picture.f->linesize[1] <<= 1;
831 s->current_picture.f->linesize[2] <<= 1;
835 mb_height = s->mb_height >> v->field_mode;
838 av_log(v->s.avctx, AV_LOG_ERROR, "Invalid mb_height.\n");
842 for (i = 0; i <= n_slices; i++) {
843 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
844 if (v->field_mode <= 0) {
845 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
846 "picture boundary (%d >= %d)\n", i,
847 slices[i - 1].mby_start, mb_height);
851 v->blocks_off = s->mb_width * s->mb_height << 1;
852 v->mb_off = s->mb_stride * s->mb_height >> 1;
859 v->pic_header_flag = 0;
860 if (v->field_mode && i == n_slices1 + 2) {
861 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
862 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
863 if (avctx->err_recognition & AV_EF_EXPLODE)
867 } else if (get_bits1(&s->gb)) {
868 v->pic_header_flag = 1;
869 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
870 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
871 if (avctx->err_recognition & AV_EF_EXPLODE)
879 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
880 if (!v->field_mode || v->second_field)
881 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
883 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
885 if (s->end_mb_y <= s->start_mb_y) {
886 av_log(v->s.avctx, AV_LOG_ERROR, "Invalid slice size\n");
890 ff_vc1_decode_blocks(v);
892 s->gb = slices[i].gb;
896 s->current_picture.f->linesize[0] >>= 1;
897 s->current_picture.f->linesize[1] >>= 1;
898 s->current_picture.f->linesize[2] >>= 1;
901 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
902 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
903 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
906 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
907 get_bits_count(&s->gb), s->gb.size_in_bits);
908 // if (get_bits_count(&s->gb) > buf_size * 8)
911 ff_er_frame_end(&s->er);
916 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
918 avctx->width = avctx->coded_width = v->output_width;
919 avctx->height = avctx->coded_height = v->output_height;
920 if (avctx->skip_frame >= AVDISCARD_NONREF)
922 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
923 if (vc1_decode_sprites(v, &s->gb))
926 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
930 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
931 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
933 ff_print_debug_info(s, s->current_picture_ptr);
935 } else if (s->last_picture_ptr) {
936 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
938 ff_print_debug_info(s, s->last_picture_ptr);
945 for (i = 0; i < n_slices; i++)
946 av_free(slices[i].buf);
952 for (i = 0; i < n_slices; i++)
953 av_free(slices[i].buf);
959 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
960 #if CONFIG_VC1_DXVA2_HWACCEL
961 AV_PIX_FMT_DXVA2_VLD,
963 #if CONFIG_VC1_D3D11VA_HWACCEL
964 AV_PIX_FMT_D3D11VA_VLD,
966 #if CONFIG_VC1_VAAPI_HWACCEL
969 #if CONFIG_VC1_VDPAU_HWACCEL
976 AVCodec ff_vc1_decoder = {
978 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
979 .type = AVMEDIA_TYPE_VIDEO,
980 .id = AV_CODEC_ID_VC1,
981 .priv_data_size = sizeof(VC1Context),
982 .init = vc1_decode_init,
983 .close = ff_vc1_decode_end,
984 .decode = vc1_decode_frame,
985 .flush = ff_mpeg_flush,
986 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
987 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
988 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
991 #if CONFIG_WMV3_DECODER
992 AVCodec ff_wmv3_decoder = {
994 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
995 .type = AVMEDIA_TYPE_VIDEO,
996 .id = AV_CODEC_ID_WMV3,
997 .priv_data_size = sizeof(VC1Context),
998 .init = vc1_decode_init,
999 .close = ff_vc1_decode_end,
1000 .decode = vc1_decode_frame,
1001 .flush = ff_mpeg_flush,
1002 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1003 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1004 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1008 #if CONFIG_WMV3IMAGE_DECODER
1009 AVCodec ff_wmv3image_decoder = {
1010 .name = "wmv3image",
1011 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1012 .type = AVMEDIA_TYPE_VIDEO,
1013 .id = AV_CODEC_ID_WMV3IMAGE,
1014 .priv_data_size = sizeof(VC1Context),
1015 .init = vc1_decode_init,
1016 .close = ff_vc1_decode_end,
1017 .decode = vc1_decode_frame,
1018 .capabilities = AV_CODEC_CAP_DR1,
1019 .flush = vc1_sprite_flush,
1020 .pix_fmts = (const enum AVPixelFormat[]) {
1027 #if CONFIG_VC1IMAGE_DECODER
1028 AVCodec ff_vc1image_decoder = {
1030 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1031 .type = AVMEDIA_TYPE_VIDEO,
1032 .id = AV_CODEC_ID_VC1IMAGE,
1033 .priv_data_size = sizeof(VC1Context),
1034 .init = vc1_decode_init,
1035 .close = ff_vc1_decode_end,
1036 .decode = vc1_decode_frame,
1037 .capabilities = AV_CODEC_CAP_DR1,
1038 .flush = vc1_sprite_flush,
1039 .pix_fmts = (const enum AVPixelFormat[]) {