Merge commit '01f0e6a0c9270f1d5bef08459a6f167cf55e0596'
[ffmpeg.git] / libavcodec / vc1dec.c
1 /*
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
6  *
7  * This file is part of FFmpeg.
8  *
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.
13  *
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.
18  *
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
22  */
23
24 /**
25  * @file
26  * VC-1 and WMV3 decoder
27  */
28
29 #include "avcodec.h"
30 #include "blockdsp.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 #include "mpeg_er.h"
34 #include "mpegvideo.h"
35 #include "msmpeg4.h"
36 #include "msmpeg4data.h"
37 #include "profiles.h"
38 #include "vc1.h"
39 #include "vc1data.h"
40 #include "vdpau_compat.h"
41 #include "libavutil/avassert.h"
42
43
44 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
45
46 typedef struct SpriteData {
47     /**
48      * Transform coefficients for both sprites in 16.16 fixed point format,
49      * in the order they appear in the bitstream:
50      *  x scale
51      *  rotation 1 (unused)
52      *  x offset
53      *  rotation 2 (unused)
54      *  y scale
55      *  y offset
56      *  alpha
57      */
58     int coefs[2][7];
59
60     int effect_type, effect_flag;
61     int effect_pcount1, effect_pcount2;   ///< amount of effect parameters stored in effect_params
62     int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
63 } SpriteData;
64
65 static inline int get_fp_val(GetBitContext* gb)
66 {
67     return (get_bits_long(gb, 30) - (1 << 29)) << 1;
68 }
69
70 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
71 {
72     c[1] = c[3] = 0;
73
74     switch (get_bits(gb, 2)) {
75     case 0:
76         c[0] = 1 << 16;
77         c[2] = get_fp_val(gb);
78         c[4] = 1 << 16;
79         break;
80     case 1:
81         c[0] = c[4] = get_fp_val(gb);
82         c[2] = get_fp_val(gb);
83         break;
84     case 2:
85         c[0] = get_fp_val(gb);
86         c[2] = get_fp_val(gb);
87         c[4] = get_fp_val(gb);
88         break;
89     case 3:
90         c[0] = get_fp_val(gb);
91         c[1] = get_fp_val(gb);
92         c[2] = get_fp_val(gb);
93         c[3] = get_fp_val(gb);
94         c[4] = get_fp_val(gb);
95         break;
96     }
97     c[5] = get_fp_val(gb);
98     if (get_bits1(gb))
99         c[6] = get_fp_val(gb);
100     else
101         c[6] = 1 << 16;
102 }
103
104 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
105 {
106     AVCodecContext *avctx = v->s.avctx;
107     int sprite, i;
108
109     for (sprite = 0; sprite <= v->two_sprites; sprite++) {
110         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
111         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
112             avpriv_request_sample(avctx, "Non-zero rotation coefficients");
113         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
114         for (i = 0; i < 7; i++)
115             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
116                    sd->coefs[sprite][i] / (1<<16),
117                    (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
118         av_log(avctx, AV_LOG_DEBUG, "\n");
119     }
120
121     skip_bits(gb, 2);
122     if (sd->effect_type = get_bits_long(gb, 30)) {
123         switch (sd->effect_pcount1 = get_bits(gb, 4)) {
124         case 7:
125             vc1_sprite_parse_transform(gb, sd->effect_params1);
126             break;
127         case 14:
128             vc1_sprite_parse_transform(gb, sd->effect_params1);
129             vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
130             break;
131         default:
132             for (i = 0; i < sd->effect_pcount1; i++)
133                 sd->effect_params1[i] = get_fp_val(gb);
134         }
135         if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
136             // effect 13 is simple alpha blending and matches the opacity above
137             av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
138             for (i = 0; i < sd->effect_pcount1; i++)
139                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
140                        sd->effect_params1[i] / (1 << 16),
141                        (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
142             av_log(avctx, AV_LOG_DEBUG, "\n");
143         }
144
145         sd->effect_pcount2 = get_bits(gb, 16);
146         if (sd->effect_pcount2 > 10) {
147             av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
148             return AVERROR_INVALIDDATA;
149         } else if (sd->effect_pcount2) {
150             i = -1;
151             av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
152             while (++i < sd->effect_pcount2) {
153                 sd->effect_params2[i] = get_fp_val(gb);
154                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
155                        sd->effect_params2[i] / (1 << 16),
156                        (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
157             }
158             av_log(avctx, AV_LOG_DEBUG, "\n");
159         }
160     }
161     if (sd->effect_flag = get_bits1(gb))
162         av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
163
164     if (get_bits_count(gb) >= gb->size_in_bits +
165        (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
166         av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
167         return AVERROR_INVALIDDATA;
168     }
169     if (get_bits_count(gb) < gb->size_in_bits - 8)
170         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
171
172     return 0;
173 }
174
175 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
176 {
177     int i, plane, row, sprite;
178     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
179     uint8_t* src_h[2][2];
180     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
181     int ysub[2];
182     MpegEncContext *s = &v->s;
183
184     for (i = 0; i <= v->two_sprites; i++) {
185         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
186         xadv[i] = sd->coefs[i][0];
187         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
188             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
189
190         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
191         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
192     }
193     alpha = av_clip_uint16(sd->coefs[1][6]);
194
195     for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
196         int width = v->output_width>>!!plane;
197
198         for (row = 0; row < v->output_height>>!!plane; row++) {
199             uint8_t *dst = v->sprite_output_frame->data[plane] +
200                            v->sprite_output_frame->linesize[plane] * row;
201
202             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
203                 uint8_t *iplane = s->current_picture.f->data[plane];
204                 int      iline  = s->current_picture.f->linesize[plane];
205                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
206                 int      yline  = ycoord >> 16;
207                 int      next_line;
208                 ysub[sprite] = ycoord & 0xFFFF;
209                 if (sprite) {
210                     iplane = s->last_picture.f->data[plane];
211                     iline  = s->last_picture.f->linesize[plane];
212                 }
213                 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
214                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
215                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
216                     if (ysub[sprite])
217                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
218                 } else {
219                     if (sr_cache[sprite][0] != yline) {
220                         if (sr_cache[sprite][1] == yline) {
221                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
222                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
223                         } else {
224                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
225                             sr_cache[sprite][0] = yline;
226                         }
227                     }
228                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
229                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
230                                            iplane + next_line, xoff[sprite],
231                                            xadv[sprite], width);
232                         sr_cache[sprite][1] = yline + 1;
233                     }
234                     src_h[sprite][0] = v->sr_rows[sprite][0];
235                     src_h[sprite][1] = v->sr_rows[sprite][1];
236                 }
237             }
238
239             if (!v->two_sprites) {
240                 if (ysub[0]) {
241                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
242                 } else {
243                     memcpy(dst, src_h[0][0], width);
244                 }
245             } else {
246                 if (ysub[0] && ysub[1]) {
247                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
248                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
249                 } else if (ysub[0]) {
250                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
251                                                        src_h[1][0], alpha, width);
252                 } else if (ysub[1]) {
253                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
254                                                        src_h[0][0], (1<<16)-1-alpha, width);
255                 } else {
256                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
257                 }
258             }
259         }
260
261         if (!plane) {
262             for (i = 0; i <= v->two_sprites; i++) {
263                 xoff[i] >>= 1;
264                 yoff[i] >>= 1;
265             }
266         }
267
268     }
269 }
270
271
272 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
273 {
274     int ret;
275     MpegEncContext *s     = &v->s;
276     AVCodecContext *avctx = s->avctx;
277     SpriteData sd;
278
279     memset(&sd, 0, sizeof(sd));
280
281     ret = vc1_parse_sprites(v, gb, &sd);
282     if (ret < 0)
283         return ret;
284
285     if (!s->current_picture.f || !s->current_picture.f->data[0]) {
286         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
287         return AVERROR_UNKNOWN;
288     }
289
290     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
291         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
292         v->two_sprites = 0;
293     }
294
295     av_frame_unref(v->sprite_output_frame);
296     if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
297         return ret;
298
299     vc1_draw_sprites(v, &sd);
300
301     return 0;
302 }
303
304 static void vc1_sprite_flush(AVCodecContext *avctx)
305 {
306     VC1Context *v     = avctx->priv_data;
307     MpegEncContext *s = &v->s;
308     AVFrame *f = s->current_picture.f;
309     int plane, i;
310
311     /* Windows Media Image codecs have a convergence interval of two keyframes.
312        Since we can't enforce it, clear to black the missing sprite. This is
313        wrong but it looks better than doing nothing. */
314
315     if (f && f->data[0])
316         for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
317             for (i = 0; i < v->sprite_height>>!!plane; i++)
318                 memset(f->data[plane] + i * f->linesize[plane],
319                        plane ? 128 : 0, f->linesize[plane]);
320 }
321
322 #endif
323
324 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
325 {
326     MpegEncContext *s = &v->s;
327     int i;
328     int mb_height = FFALIGN(s->mb_height, 2);
329
330     /* Allocate mb bitplanes */
331     v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
332     v->direct_mb_plane  = av_malloc (s->mb_stride * mb_height);
333     v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
334     v->fieldtx_plane    = av_mallocz(s->mb_stride * mb_height);
335     v->acpred_plane     = av_malloc (s->mb_stride * mb_height);
336     v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
337
338     v->n_allocated_blks = s->mb_width + 2;
339     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
340     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
341     v->cbp              = v->cbp_base + s->mb_stride;
342     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
343     v->ttblk            = v->ttblk_base + s->mb_stride;
344     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
345     v->is_intra         = v->is_intra_base + s->mb_stride;
346     v->luma_mv_base     = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
347     v->luma_mv          = v->luma_mv_base + s->mb_stride;
348
349     /* allocate block type info in that way so it could be used with s->block_index[] */
350     v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
351     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
352     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
353     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (mb_height + 1);
354
355     /* allocate memory to store block level MV info */
356     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
357     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
358     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
359     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
360     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
361     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
362     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
363     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
365     ff_intrax8_common_init(&v->x8,s);
366
367     if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
368         for (i = 0; i < 4; i++)
369             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
370                 return AVERROR(ENOMEM);
371     }
372
373     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
374         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
375         !v->mb_type_base) {
376         goto error;
377     }
378
379     return 0;
380
381 error:
382     ff_vc1_decode_end(s->avctx);
383     return AVERROR(ENOMEM);
384 }
385
386 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
387 {
388     int i;
389     for (i = 0; i < 64; i++) {
390 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
391         v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
392         v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
393         v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
394         v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
395         v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
396     }
397     v->left_blk_sh = 0;
398     v->top_blk_sh  = 3;
399 }
400
401 /** Initialize a VC1/WMV3 decoder
402  * @todo TODO: Handle VC-1 IDUs (Transport level?)
403  * @todo TODO: Decypher remaining bits in extra_data
404  */
405 static av_cold int vc1_decode_init(AVCodecContext *avctx)
406 {
407     VC1Context *v = avctx->priv_data;
408     MpegEncContext *s = &v->s;
409     GetBitContext gb;
410     int ret;
411
412     /* save the container output size for WMImage */
413     v->output_width  = avctx->width;
414     v->output_height = avctx->height;
415
416     if (!avctx->extradata_size || !avctx->extradata)
417         return -1;
418     v->s.avctx = avctx;
419
420     if ((ret = ff_vc1_init_common(v)) < 0)
421         return ret;
422
423     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
424         int count = 0;
425
426         // looks like WMV3 has a sequence header stored in the extradata
427         // advanced sequence header may be before the first frame
428         // the last byte of the extradata is a version number, 1 for the
429         // samples we can decode
430
431         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
432
433         if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
434           return ret;
435
436         count = avctx->extradata_size*8 - get_bits_count(&gb);
437         if (count > 0) {
438             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
439                    count, get_bits_long(&gb, FFMIN(count, 32)));
440         } else if (count < 0) {
441             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
442         }
443     } else { // VC1/WVC1/WVP2
444         const uint8_t *start = avctx->extradata;
445         uint8_t *end = avctx->extradata + avctx->extradata_size;
446         const uint8_t *next;
447         int size, buf2_size;
448         uint8_t *buf2 = NULL;
449         int seq_initialized = 0, ep_initialized = 0;
450
451         if (avctx->extradata_size < 16) {
452             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
453             return -1;
454         }
455
456         buf2  = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
457         if (!buf2)
458             return AVERROR(ENOMEM);
459
460         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
461         next  = start;
462         for (; next < end; start = next) {
463             next = find_next_marker(start + 4, end);
464             size = next - start - 4;
465             if (size <= 0)
466                 continue;
467             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
468             init_get_bits(&gb, buf2, buf2_size * 8);
469             switch (AV_RB32(start)) {
470             case VC1_CODE_SEQHDR:
471                 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
472                     av_free(buf2);
473                     return ret;
474                 }
475                 seq_initialized = 1;
476                 break;
477             case VC1_CODE_ENTRYPOINT:
478                 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
479                     av_free(buf2);
480                     return ret;
481                 }
482                 ep_initialized = 1;
483                 break;
484             }
485         }
486         av_free(buf2);
487         if (!seq_initialized || !ep_initialized) {
488             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
489             return -1;
490         }
491         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
492     }
493
494     avctx->profile = v->profile;
495     if (v->profile == PROFILE_ADVANCED)
496         avctx->level = v->level;
497
498     if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
499         avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
500     else {
501         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
502         if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
503             avctx->color_range = AVCOL_RANGE_MPEG;
504     }
505
506     // ensure static VLC tables are initialized
507     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
508         return ret;
509     if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
510         return ret;
511     // Hack to ensure the above functions will be called
512     // again once we know all necessary settings.
513     // That this is necessary might indicate a bug.
514     ff_vc1_decode_end(avctx);
515
516     ff_blockdsp_init(&s->bdsp, avctx);
517     ff_h264chroma_init(&v->h264chroma, 8);
518     ff_qpeldsp_init(&s->qdsp);
519
520     // Must happen after calling ff_vc1_decode_end
521     // to avoid de-allocating the sprite_output_frame
522     v->sprite_output_frame = av_frame_alloc();
523     if (!v->sprite_output_frame)
524         return AVERROR(ENOMEM);
525
526     avctx->has_b_frames = !!avctx->max_b_frames;
527
528     if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
529         avctx->color_primaries = v->color_prim;
530     if (v->transfer_char == 1 || v->transfer_char == 7)
531         avctx->color_trc = v->transfer_char;
532     if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
533         avctx->colorspace = v->matrix_coef;
534
535     s->mb_width  = (avctx->coded_width  + 15) >> 4;
536     s->mb_height = (avctx->coded_height + 15) >> 4;
537
538     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
539         ff_vc1_init_transposed_scantables(v);
540     } else {
541         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
542         v->left_blk_sh = 3;
543         v->top_blk_sh  = 0;
544     }
545
546     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
547         v->sprite_width  = avctx->coded_width;
548         v->sprite_height = avctx->coded_height;
549
550         avctx->coded_width  = avctx->width  = v->output_width;
551         avctx->coded_height = avctx->height = v->output_height;
552
553         // prevent 16.16 overflows
554         if (v->sprite_width  > 1 << 14 ||
555             v->sprite_height > 1 << 14 ||
556             v->output_width  > 1 << 14 ||
557             v->output_height > 1 << 14) return -1;
558
559         if ((v->sprite_width&1) || (v->sprite_height&1)) {
560             avpriv_request_sample(avctx, "odd sprites support");
561             return AVERROR_PATCHWELCOME;
562         }
563     }
564     return 0;
565 }
566
567 /** Close a VC1/WMV3 decoder
568  * @warning Initial try at using MpegEncContext stuff
569  */
570 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
571 {
572     VC1Context *v = avctx->priv_data;
573     int i;
574
575     av_frame_free(&v->sprite_output_frame);
576
577     for (i = 0; i < 4; i++)
578         av_freep(&v->sr_rows[i >> 1][i & 1]);
579     av_freep(&v->hrd_rate);
580     av_freep(&v->hrd_buffer);
581     ff_mpv_common_end(&v->s);
582     av_freep(&v->mv_type_mb_plane);
583     av_freep(&v->direct_mb_plane);
584     av_freep(&v->forward_mb_plane);
585     av_freep(&v->fieldtx_plane);
586     av_freep(&v->acpred_plane);
587     av_freep(&v->over_flags_plane);
588     av_freep(&v->mb_type_base);
589     av_freep(&v->blk_mv_type_base);
590     av_freep(&v->mv_f_base);
591     av_freep(&v->mv_f_next_base);
592     av_freep(&v->block);
593     av_freep(&v->cbp_base);
594     av_freep(&v->ttblk_base);
595     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
596     av_freep(&v->luma_mv_base);
597     ff_intrax8_common_end(&v->x8);
598     return 0;
599 }
600
601
602 /** Decode a VC1/WMV3 frame
603  * @todo TODO: Handle VC-1 IDUs (Transport level?)
604  */
605 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
606                             int *got_frame, AVPacket *avpkt)
607 {
608     const uint8_t *buf = avpkt->data;
609     int buf_size = avpkt->size, n_slices = 0, i, ret;
610     VC1Context *v = avctx->priv_data;
611     MpegEncContext *s = &v->s;
612     AVFrame *pict = data;
613     uint8_t *buf2 = NULL;
614     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
615     int mb_height, n_slices1=-1;
616     struct {
617         uint8_t *buf;
618         GetBitContext gb;
619         int mby_start;
620     } *slices = NULL, *tmp;
621
622     v->second_field = 0;
623
624     if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
625         s->low_delay = 1;
626
627     /* no supplementary picture */
628     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
629         /* special case for last picture */
630         if (s->low_delay == 0 && s->next_picture_ptr) {
631             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
632                 return ret;
633             s->next_picture_ptr = NULL;
634
635             *got_frame = 1;
636         }
637
638         return buf_size;
639     }
640
641 #if FF_API_CAP_VDPAU
642     if (s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
643         if (v->profile < PROFILE_ADVANCED)
644             avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
645         else
646             avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
647     }
648 #endif
649
650     //for advanced profile we may need to parse and unescape data
651     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
652         int buf_size2 = 0;
653         buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
654         if (!buf2)
655             return AVERROR(ENOMEM);
656
657         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
658             const uint8_t *start, *end, *next;
659             int size;
660
661             next = buf;
662             for (start = buf, end = buf + buf_size; next < end; start = next) {
663                 next = find_next_marker(start + 4, end);
664                 size = next - start - 4;
665                 if (size <= 0) continue;
666                 switch (AV_RB32(start)) {
667                 case VC1_CODE_FRAME:
668                     if (avctx->hwaccel
669 #if FF_API_CAP_VDPAU
670                         || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
671 #endif
672                         )
673                         buf_start = start;
674                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
675                     break;
676                 case VC1_CODE_FIELD: {
677                     int buf_size3;
678                     if (avctx->hwaccel
679 #if FF_API_CAP_VDPAU
680                         || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
681 #endif
682                         )
683                         buf_start_second_field = start;
684                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
685                     if (!tmp) {
686                         ret = AVERROR(ENOMEM);
687                         goto err;
688                     }
689                     slices = tmp;
690                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
691                     if (!slices[n_slices].buf) {
692                         ret = AVERROR(ENOMEM);
693                         goto err;
694                     }
695                     buf_size3 = vc1_unescape_buffer(start + 4, size,
696                                                     slices[n_slices].buf);
697                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
698                                   buf_size3 << 3);
699                     /* assuming that the field marker is at the exact middle,
700                        hope it's correct */
701                     slices[n_slices].mby_start = s->mb_height + 1 >> 1;
702                     n_slices1 = n_slices - 1; // index of the last slice of the first field
703                     n_slices++;
704                     break;
705                 }
706                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
707                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
708                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
709                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
710                     break;
711                 case VC1_CODE_SLICE: {
712                     int buf_size3;
713                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
714                     if (!tmp) {
715                         ret = AVERROR(ENOMEM);
716                         goto err;
717                     }
718                     slices = tmp;
719                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
720                     if (!slices[n_slices].buf) {
721                         ret = AVERROR(ENOMEM);
722                         goto err;
723                     }
724                     buf_size3 = vc1_unescape_buffer(start + 4, size,
725                                                     slices[n_slices].buf);
726                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
727                                   buf_size3 << 3);
728                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
729                     n_slices++;
730                     break;
731                 }
732                 }
733             }
734         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
735             const uint8_t *divider;
736             int buf_size3;
737
738             divider = find_next_marker(buf, buf + buf_size);
739             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
740                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
741                 ret = AVERROR_INVALIDDATA;
742                 goto err;
743             } else { // found field marker, unescape second field
744                 if (avctx->hwaccel
745 #if FF_API_CAP_VDPAU
746                     || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
747 #endif
748                     )
749                     buf_start_second_field = divider;
750                 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
751                 if (!tmp) {
752                     ret = AVERROR(ENOMEM);
753                     goto err;
754                 }
755                 slices = tmp;
756                 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
757                 if (!slices[n_slices].buf) {
758                     ret = AVERROR(ENOMEM);
759                     goto err;
760                 }
761                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
762                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
763                               buf_size3 << 3);
764                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
765                 n_slices1 = n_slices - 1;
766                 n_slices++;
767             }
768             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
769         } else {
770             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
771         }
772         init_get_bits(&s->gb, buf2, buf_size2*8);
773     } else
774         init_get_bits(&s->gb, buf, buf_size*8);
775
776     if (v->res_sprite) {
777         v->new_sprite  = !get_bits1(&s->gb);
778         v->two_sprites =  get_bits1(&s->gb);
779         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
780            we're using the sprite compositor. These are intentionally kept separate
781            so you can get the raw sprites by using the wmv3 decoder for WMVP or
782            the vc1 one for WVP2 */
783         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
784             if (v->new_sprite) {
785                 // switch AVCodecContext parameters to those of the sprites
786                 avctx->width  = avctx->coded_width  = v->sprite_width;
787                 avctx->height = avctx->coded_height = v->sprite_height;
788             } else {
789                 goto image;
790             }
791         }
792     }
793
794     if (s->context_initialized &&
795         (s->width  != avctx->coded_width ||
796          s->height != avctx->coded_height)) {
797         ff_vc1_decode_end(avctx);
798     }
799
800     if (!s->context_initialized) {
801         if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
802             goto err;
803         if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
804             ff_mpv_common_end(s);
805             goto err;
806         }
807
808         s->low_delay = !avctx->has_b_frames || v->res_sprite;
809
810         if (v->profile == PROFILE_ADVANCED) {
811             if(avctx->coded_width<=1 || avctx->coded_height<=1) {
812                 ret = AVERROR_INVALIDDATA;
813                 goto err;
814             }
815             s->h_edge_pos = avctx->coded_width;
816             s->v_edge_pos = avctx->coded_height;
817         }
818     }
819
820     // do parse frame header
821     v->pic_header_flag = 0;
822     v->first_pic_header_flag = 1;
823     if (v->profile < PROFILE_ADVANCED) {
824         if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
825             goto err;
826         }
827     } else {
828         if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
829             goto err;
830         }
831     }
832     v->first_pic_header_flag = 0;
833
834     if (avctx->debug & FF_DEBUG_PICT_INFO)
835         av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
836
837     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
838         && s->pict_type != AV_PICTURE_TYPE_I) {
839         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
840         ret = AVERROR_INVALIDDATA;
841         goto err;
842     }
843
844     if ((s->mb_height >> v->field_mode) == 0) {
845         av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
846         ret = AVERROR_INVALIDDATA;
847         goto err;
848     }
849
850     // for skipping the frame
851     s->current_picture.f->pict_type = s->pict_type;
852     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
853
854     /* skip B-frames if we don't have reference frames */
855     if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
856         av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
857         goto end;
858     }
859     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
860         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
861          avctx->skip_frame >= AVDISCARD_ALL) {
862         goto end;
863     }
864
865     if (s->next_p_frame_damaged) {
866         if (s->pict_type == AV_PICTURE_TYPE_B)
867             goto end;
868         else
869             s->next_p_frame_damaged = 0;
870     }
871
872     if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
873         goto err;
874     }
875
876     v->s.current_picture_ptr->field_picture = v->field_mode;
877     v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
878     v->s.current_picture_ptr->f->top_field_first  = v->tff;
879
880     // process pulldown flags
881     s->current_picture_ptr->f->repeat_pict = 0;
882     // Pulldown flags are only valid when 'broadcast' has been set.
883     // So ticks_per_frame will be 2
884     if (v->rff) {
885         // repeat field
886         s->current_picture_ptr->f->repeat_pict = 1;
887     } else if (v->rptfrm) {
888         // repeat frames
889         s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
890     }
891
892     s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
893     s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
894
895 #if FF_API_CAP_VDPAU
896     if ((CONFIG_VC1_VDPAU_DECODER)
897         &&s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
898         if (v->field_mode && buf_start_second_field) {
899             ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
900             ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
901         } else {
902             ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
903         }
904     } else
905 #endif
906     if (avctx->hwaccel) {
907         if (v->field_mode && buf_start_second_field) {
908             // decode first field
909             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
910             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
911                 goto err;
912             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
913                 goto err;
914             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
915                 goto err;
916
917             // decode second field
918             s->gb = slices[n_slices1 + 1].gb;
919             s->picture_structure = PICT_TOP_FIELD + v->tff;
920             v->second_field = 1;
921             v->pic_header_flag = 0;
922             if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
923                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
924                 ret = AVERROR_INVALIDDATA;
925                 goto err;
926             }
927             v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
928
929             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
930                 goto err;
931             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
932                 goto err;
933             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
934                 goto err;
935         } else {
936             s->picture_structure = PICT_FRAME;
937             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
938                 goto err;
939             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
940                 goto err;
941             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
942                 goto err;
943         }
944     } else {
945         int header_ret = 0;
946
947         ff_mpeg_er_frame_start(s);
948
949         v->bits = buf_size * 8;
950         v->end_mb_x = s->mb_width;
951         if (v->field_mode) {
952             s->current_picture.f->linesize[0] <<= 1;
953             s->current_picture.f->linesize[1] <<= 1;
954             s->current_picture.f->linesize[2] <<= 1;
955             s->linesize                      <<= 1;
956             s->uvlinesize                    <<= 1;
957         }
958         mb_height = s->mb_height >> v->field_mode;
959
960         av_assert0 (mb_height > 0);
961
962         for (i = 0; i <= n_slices; i++) {
963             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
964                 if (v->field_mode <= 0) {
965                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
966                            "picture boundary (%d >= %d)\n", i,
967                            slices[i - 1].mby_start, mb_height);
968                     continue;
969                 }
970                 v->second_field = 1;
971                 av_assert0((s->mb_height & 1) == 0);
972                 v->blocks_off   = s->b8_stride * (s->mb_height&~1);
973                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
974             } else {
975                 v->second_field = 0;
976                 v->blocks_off   = 0;
977                 v->mb_off       = 0;
978             }
979             if (i) {
980                 v->pic_header_flag = 0;
981                 if (v->field_mode && i == n_slices1 + 2) {
982                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
983                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
984                         ret = AVERROR_INVALIDDATA;
985                         if (avctx->err_recognition & AV_EF_EXPLODE)
986                             goto err;
987                         continue;
988                     }
989                 } else if (get_bits1(&s->gb)) {
990                     v->pic_header_flag = 1;
991                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
992                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
993                         ret = AVERROR_INVALIDDATA;
994                         if (avctx->err_recognition & AV_EF_EXPLODE)
995                             goto err;
996                         continue;
997                     }
998                 }
999             }
1000             if (header_ret < 0)
1001                 continue;
1002             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1003             if (!v->field_mode || v->second_field)
1004                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1005             else {
1006                 if (i >= n_slices) {
1007                     av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1008                     continue;
1009                 }
1010                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1011             }
1012             if (s->end_mb_y <= s->start_mb_y) {
1013                 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1014                 continue;
1015             }
1016             if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1017                 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1018                 continue;
1019             }
1020             ff_vc1_decode_blocks(v);
1021             if (i != n_slices)
1022                 s->gb = slices[i].gb;
1023         }
1024         if (v->field_mode) {
1025             v->second_field = 0;
1026             s->current_picture.f->linesize[0] >>= 1;
1027             s->current_picture.f->linesize[1] >>= 1;
1028             s->current_picture.f->linesize[2] >>= 1;
1029             s->linesize                      >>= 1;
1030             s->uvlinesize                    >>= 1;
1031             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1032                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1033                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1034             }
1035         }
1036         ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1037                 get_bits_count(&s->gb), s->gb.size_in_bits);
1038 //  if (get_bits_count(&s->gb) > buf_size * 8)
1039 //      return -1;
1040         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1041             ret = AVERROR_INVALIDDATA;
1042             goto err;
1043         }
1044         if (!v->field_mode)
1045             ff_er_frame_end(&s->er);
1046     }
1047
1048     ff_mpv_frame_end(s);
1049
1050     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1051 image:
1052         avctx->width  = avctx->coded_width  = v->output_width;
1053         avctx->height = avctx->coded_height = v->output_height;
1054         if (avctx->skip_frame >= AVDISCARD_NONREF)
1055             goto end;
1056 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1057         if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1058             goto err;
1059 #endif
1060         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1061             goto err;
1062         *got_frame = 1;
1063     } else {
1064         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1065             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1066                 goto err;
1067             ff_print_debug_info(s, s->current_picture_ptr, pict);
1068             *got_frame = 1;
1069         } else if (s->last_picture_ptr) {
1070             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1071                 goto err;
1072             ff_print_debug_info(s, s->last_picture_ptr, pict);
1073             *got_frame = 1;
1074         }
1075     }
1076
1077 end:
1078     av_free(buf2);
1079     for (i = 0; i < n_slices; i++)
1080         av_free(slices[i].buf);
1081     av_free(slices);
1082     return buf_size;
1083
1084 err:
1085     av_free(buf2);
1086     for (i = 0; i < n_slices; i++)
1087         av_free(slices[i].buf);
1088     av_free(slices);
1089     return ret;
1090 }
1091
1092
1093 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1094 #if CONFIG_VC1_DXVA2_HWACCEL
1095     AV_PIX_FMT_DXVA2_VLD,
1096 #endif
1097 #if CONFIG_VC1_D3D11VA_HWACCEL
1098     AV_PIX_FMT_D3D11VA_VLD,
1099 #endif
1100 #if CONFIG_VC1_VAAPI_HWACCEL
1101     AV_PIX_FMT_VAAPI,
1102 #endif
1103 #if CONFIG_VC1_VDPAU_HWACCEL
1104     AV_PIX_FMT_VDPAU,
1105 #endif
1106     AV_PIX_FMT_YUV420P,
1107     AV_PIX_FMT_NONE
1108 };
1109
1110 AVCodec ff_vc1_decoder = {
1111     .name           = "vc1",
1112     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1113     .type           = AVMEDIA_TYPE_VIDEO,
1114     .id             = AV_CODEC_ID_VC1,
1115     .priv_data_size = sizeof(VC1Context),
1116     .init           = vc1_decode_init,
1117     .close          = ff_vc1_decode_end,
1118     .decode         = vc1_decode_frame,
1119     .flush          = ff_mpeg_flush,
1120     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1121     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1122     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1123 };
1124
1125 #if CONFIG_WMV3_DECODER
1126 AVCodec ff_wmv3_decoder = {
1127     .name           = "wmv3",
1128     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1129     .type           = AVMEDIA_TYPE_VIDEO,
1130     .id             = AV_CODEC_ID_WMV3,
1131     .priv_data_size = sizeof(VC1Context),
1132     .init           = vc1_decode_init,
1133     .close          = ff_vc1_decode_end,
1134     .decode         = vc1_decode_frame,
1135     .flush          = ff_mpeg_flush,
1136     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1137     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1138     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1139 };
1140 #endif
1141
1142 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1143 AVCodec ff_wmv3_vdpau_decoder = {
1144     .name           = "wmv3_vdpau",
1145     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
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     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1153     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1154     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1155 };
1156 #endif
1157
1158 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1159 AVCodec ff_vc1_vdpau_decoder = {
1160     .name           = "vc1_vdpau",
1161     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1162     .type           = AVMEDIA_TYPE_VIDEO,
1163     .id             = AV_CODEC_ID_VC1,
1164     .priv_data_size = sizeof(VC1Context),
1165     .init           = vc1_decode_init,
1166     .close          = ff_vc1_decode_end,
1167     .decode         = vc1_decode_frame,
1168     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1169     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1170     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1171 };
1172 #endif
1173
1174 #if CONFIG_WMV3IMAGE_DECODER
1175 AVCodec ff_wmv3image_decoder = {
1176     .name           = "wmv3image",
1177     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1178     .type           = AVMEDIA_TYPE_VIDEO,
1179     .id             = AV_CODEC_ID_WMV3IMAGE,
1180     .priv_data_size = sizeof(VC1Context),
1181     .init           = vc1_decode_init,
1182     .close          = ff_vc1_decode_end,
1183     .decode         = vc1_decode_frame,
1184     .capabilities   = AV_CODEC_CAP_DR1,
1185     .flush          = vc1_sprite_flush,
1186     .pix_fmts       = (const enum AVPixelFormat[]) {
1187         AV_PIX_FMT_YUV420P,
1188         AV_PIX_FMT_NONE
1189     },
1190 };
1191 #endif
1192
1193 #if CONFIG_VC1IMAGE_DECODER
1194 AVCodec ff_vc1image_decoder = {
1195     .name           = "vc1image",
1196     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1197     .type           = AVMEDIA_TYPE_VIDEO,
1198     .id             = AV_CODEC_ID_VC1IMAGE,
1199     .priv_data_size = sizeof(VC1Context),
1200     .init           = vc1_decode_init,
1201     .close          = ff_vc1_decode_end,
1202     .decode         = vc1_decode_frame,
1203     .capabilities   = AV_CODEC_CAP_DR1,
1204     .flush          = vc1_sprite_flush,
1205     .pix_fmts       = (const enum AVPixelFormat[]) {
1206         AV_PIX_FMT_YUV420P,
1207         AV_PIX_FMT_NONE
1208     },
1209 };
1210 #endif