Merge commit 'e66fa35392cd45d0a80774cd057fb765d60def43'
[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     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
338         !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
339         goto error;
340
341     v->n_allocated_blks = s->mb_width + 2;
342     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
343     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
344     if (!v->block || !v->cbp_base)
345         goto error;
346     v->cbp              = v->cbp_base + s->mb_stride;
347     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
348     if (!v->ttblk_base)
349         goto error;
350     v->ttblk            = v->ttblk_base + s->mb_stride;
351     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
352     if (!v->is_intra_base)
353         goto error;
354     v->is_intra         = v->is_intra_base + s->mb_stride;
355     v->luma_mv_base     = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
356     if (!v->luma_mv_base)
357         goto error;
358     v->luma_mv          = v->luma_mv_base + s->mb_stride;
359
360     /* allocate block type info in that way so it could be used with s->block_index[] */
361     v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362     if (!v->mb_type_base)
363         goto error;
364     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
365     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (mb_height + 1);
367
368     /* allocate memory to store block level MV info */
369     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370     if (!v->blk_mv_type_base)
371         goto error;
372     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
373     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
374     if (!v->mv_f_base)
375         goto error;
376     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
377     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379     if (!v->mv_f_next_base)
380         goto error;
381     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
382     v->mv_f_next[1]     = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
383
384     ff_intrax8_common_init(&v->x8,s);
385
386     if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
387         for (i = 0; i < 4; i++)
388             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
389                 return AVERROR(ENOMEM);
390     }
391
392     return 0;
393
394 error:
395     ff_vc1_decode_end(s->avctx);
396     return AVERROR(ENOMEM);
397 }
398
399 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
400 {
401     int i;
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]);
409     }
410     v->left_blk_sh = 0;
411     v->top_blk_sh  = 3;
412 }
413
414 /** Initialize a VC1/WMV3 decoder
415  * @todo TODO: Handle VC-1 IDUs (Transport level?)
416  * @todo TODO: Decypher remaining bits in extra_data
417  */
418 static av_cold int vc1_decode_init(AVCodecContext *avctx)
419 {
420     VC1Context *v = avctx->priv_data;
421     MpegEncContext *s = &v->s;
422     GetBitContext gb;
423     int ret;
424
425     /* save the container output size for WMImage */
426     v->output_width  = avctx->width;
427     v->output_height = avctx->height;
428
429     if (!avctx->extradata_size || !avctx->extradata)
430         return -1;
431     v->s.avctx = avctx;
432
433     if ((ret = ff_vc1_init_common(v)) < 0)
434         return ret;
435
436     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
437         int count = 0;
438
439         // looks like WMV3 has a sequence header stored in the extradata
440         // advanced sequence header may be before the first frame
441         // the last byte of the extradata is a version number, 1 for the
442         // samples we can decode
443
444         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
445
446         if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
447           return ret;
448
449         count = avctx->extradata_size*8 - get_bits_count(&gb);
450         if (count > 0) {
451             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
452                    count, get_bits_long(&gb, FFMIN(count, 32)));
453         } else if (count < 0) {
454             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
455         }
456     } else { // VC1/WVC1/WVP2
457         const uint8_t *start = avctx->extradata;
458         uint8_t *end = avctx->extradata + avctx->extradata_size;
459         const uint8_t *next;
460         int size, buf2_size;
461         uint8_t *buf2 = NULL;
462         int seq_initialized = 0, ep_initialized = 0;
463
464         if (avctx->extradata_size < 16) {
465             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
466             return -1;
467         }
468
469         buf2  = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
470         if (!buf2)
471             return AVERROR(ENOMEM);
472
473         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
474         next  = start;
475         for (; next < end; start = next) {
476             next = find_next_marker(start + 4, end);
477             size = next - start - 4;
478             if (size <= 0)
479                 continue;
480             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
481             init_get_bits(&gb, buf2, buf2_size * 8);
482             switch (AV_RB32(start)) {
483             case VC1_CODE_SEQHDR:
484                 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
485                     av_free(buf2);
486                     return ret;
487                 }
488                 seq_initialized = 1;
489                 break;
490             case VC1_CODE_ENTRYPOINT:
491                 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
492                     av_free(buf2);
493                     return ret;
494                 }
495                 ep_initialized = 1;
496                 break;
497             }
498         }
499         av_free(buf2);
500         if (!seq_initialized || !ep_initialized) {
501             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
502             return -1;
503         }
504         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
505     }
506
507     avctx->profile = v->profile;
508     if (v->profile == PROFILE_ADVANCED)
509         avctx->level = v->level;
510
511     if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
512         avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
513     else {
514         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
515         if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
516             avctx->color_range = AVCOL_RANGE_MPEG;
517     }
518
519     // ensure static VLC tables are initialized
520     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
521         return ret;
522     if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
523         return ret;
524     // Hack to ensure the above functions will be called
525     // again once we know all necessary settings.
526     // That this is necessary might indicate a bug.
527     ff_vc1_decode_end(avctx);
528
529     ff_blockdsp_init(&s->bdsp, avctx);
530     ff_h264chroma_init(&v->h264chroma, 8);
531     ff_qpeldsp_init(&s->qdsp);
532
533     // Must happen after calling ff_vc1_decode_end
534     // to avoid de-allocating the sprite_output_frame
535     v->sprite_output_frame = av_frame_alloc();
536     if (!v->sprite_output_frame)
537         return AVERROR(ENOMEM);
538
539     avctx->has_b_frames = !!avctx->max_b_frames;
540
541     if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
542         avctx->color_primaries = v->color_prim;
543     if (v->transfer_char == 1 || v->transfer_char == 7)
544         avctx->color_trc = v->transfer_char;
545     if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
546         avctx->colorspace = v->matrix_coef;
547
548     s->mb_width  = (avctx->coded_width  + 15) >> 4;
549     s->mb_height = (avctx->coded_height + 15) >> 4;
550
551     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
552         ff_vc1_init_transposed_scantables(v);
553     } else {
554         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
555         v->left_blk_sh = 3;
556         v->top_blk_sh  = 0;
557     }
558
559     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
560         v->sprite_width  = avctx->coded_width;
561         v->sprite_height = avctx->coded_height;
562
563         avctx->coded_width  = avctx->width  = v->output_width;
564         avctx->coded_height = avctx->height = v->output_height;
565
566         // prevent 16.16 overflows
567         if (v->sprite_width  > 1 << 14 ||
568             v->sprite_height > 1 << 14 ||
569             v->output_width  > 1 << 14 ||
570             v->output_height > 1 << 14) return -1;
571
572         if ((v->sprite_width&1) || (v->sprite_height&1)) {
573             avpriv_request_sample(avctx, "odd sprites support");
574             return AVERROR_PATCHWELCOME;
575         }
576     }
577     return 0;
578 }
579
580 /** Close a VC1/WMV3 decoder
581  * @warning Initial try at using MpegEncContext stuff
582  */
583 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
584 {
585     VC1Context *v = avctx->priv_data;
586     int i;
587
588     av_frame_free(&v->sprite_output_frame);
589
590     for (i = 0; i < 4; i++)
591         av_freep(&v->sr_rows[i >> 1][i & 1]);
592     av_freep(&v->hrd_rate);
593     av_freep(&v->hrd_buffer);
594     ff_mpv_common_end(&v->s);
595     av_freep(&v->mv_type_mb_plane);
596     av_freep(&v->direct_mb_plane);
597     av_freep(&v->forward_mb_plane);
598     av_freep(&v->fieldtx_plane);
599     av_freep(&v->acpred_plane);
600     av_freep(&v->over_flags_plane);
601     av_freep(&v->mb_type_base);
602     av_freep(&v->blk_mv_type_base);
603     av_freep(&v->mv_f_base);
604     av_freep(&v->mv_f_next_base);
605     av_freep(&v->block);
606     av_freep(&v->cbp_base);
607     av_freep(&v->ttblk_base);
608     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
609     av_freep(&v->luma_mv_base);
610     ff_intrax8_common_end(&v->x8);
611     return 0;
612 }
613
614
615 /** Decode a VC1/WMV3 frame
616  * @todo TODO: Handle VC-1 IDUs (Transport level?)
617  */
618 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
619                             int *got_frame, AVPacket *avpkt)
620 {
621     const uint8_t *buf = avpkt->data;
622     int buf_size = avpkt->size, n_slices = 0, i, ret;
623     VC1Context *v = avctx->priv_data;
624     MpegEncContext *s = &v->s;
625     AVFrame *pict = data;
626     uint8_t *buf2 = NULL;
627     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
628     int mb_height, n_slices1=-1;
629     struct {
630         uint8_t *buf;
631         GetBitContext gb;
632         int mby_start;
633     } *slices = NULL, *tmp;
634
635     v->second_field = 0;
636
637     if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
638         s->low_delay = 1;
639
640     /* no supplementary picture */
641     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
642         /* special case for last picture */
643         if (s->low_delay == 0 && s->next_picture_ptr) {
644             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
645                 return ret;
646             s->next_picture_ptr = NULL;
647
648             *got_frame = 1;
649         }
650
651         return buf_size;
652     }
653
654 #if FF_API_CAP_VDPAU
655     if (s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
656         if (v->profile < PROFILE_ADVANCED)
657             avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
658         else
659             avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
660     }
661 #endif
662
663     //for advanced profile we may need to parse and unescape data
664     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
665         int buf_size2 = 0;
666         buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
667         if (!buf2)
668             return AVERROR(ENOMEM);
669
670         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
671             const uint8_t *start, *end, *next;
672             int size;
673
674             next = buf;
675             for (start = buf, end = buf + buf_size; next < end; start = next) {
676                 next = find_next_marker(start + 4, end);
677                 size = next - start - 4;
678                 if (size <= 0) continue;
679                 switch (AV_RB32(start)) {
680                 case VC1_CODE_FRAME:
681                     if (avctx->hwaccel
682 #if FF_API_CAP_VDPAU
683                         || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
684 #endif
685                         )
686                         buf_start = start;
687                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
688                     break;
689                 case VC1_CODE_FIELD: {
690                     int buf_size3;
691                     if (avctx->hwaccel
692 #if FF_API_CAP_VDPAU
693                         || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
694 #endif
695                         )
696                         buf_start_second_field = start;
697                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
698                     if (!tmp) {
699                         ret = AVERROR(ENOMEM);
700                         goto err;
701                     }
702                     slices = tmp;
703                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
704                     if (!slices[n_slices].buf) {
705                         ret = AVERROR(ENOMEM);
706                         goto err;
707                     }
708                     buf_size3 = vc1_unescape_buffer(start + 4, size,
709                                                     slices[n_slices].buf);
710                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
711                                   buf_size3 << 3);
712                     /* assuming that the field marker is at the exact middle,
713                        hope it's correct */
714                     slices[n_slices].mby_start = s->mb_height + 1 >> 1;
715                     n_slices1 = n_slices - 1; // index of the last slice of the first field
716                     n_slices++;
717                     break;
718                 }
719                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
720                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
721                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
722                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
723                     break;
724                 case VC1_CODE_SLICE: {
725                     int buf_size3;
726                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
727                     if (!tmp) {
728                         ret = AVERROR(ENOMEM);
729                         goto err;
730                     }
731                     slices = tmp;
732                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
733                     if (!slices[n_slices].buf) {
734                         ret = AVERROR(ENOMEM);
735                         goto err;
736                     }
737                     buf_size3 = vc1_unescape_buffer(start + 4, size,
738                                                     slices[n_slices].buf);
739                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
740                                   buf_size3 << 3);
741                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
742                     n_slices++;
743                     break;
744                 }
745                 }
746             }
747         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
748             const uint8_t *divider;
749             int buf_size3;
750
751             divider = find_next_marker(buf, buf + buf_size);
752             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
753                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
754                 ret = AVERROR_INVALIDDATA;
755                 goto err;
756             } else { // found field marker, unescape second field
757                 if (avctx->hwaccel
758 #if FF_API_CAP_VDPAU
759                     || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
760 #endif
761                     )
762                     buf_start_second_field = divider;
763                 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
764                 if (!tmp) {
765                     ret = AVERROR(ENOMEM);
766                     goto err;
767                 }
768                 slices = tmp;
769                 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
770                 if (!slices[n_slices].buf) {
771                     ret = AVERROR(ENOMEM);
772                     goto err;
773                 }
774                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
775                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
776                               buf_size3 << 3);
777                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
778                 n_slices1 = n_slices - 1;
779                 n_slices++;
780             }
781             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
782         } else {
783             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
784         }
785         init_get_bits(&s->gb, buf2, buf_size2*8);
786     } else
787         init_get_bits(&s->gb, buf, buf_size*8);
788
789     if (v->res_sprite) {
790         v->new_sprite  = !get_bits1(&s->gb);
791         v->two_sprites =  get_bits1(&s->gb);
792         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
793            we're using the sprite compositor. These are intentionally kept separate
794            so you can get the raw sprites by using the wmv3 decoder for WMVP or
795            the vc1 one for WVP2 */
796         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
797             if (v->new_sprite) {
798                 // switch AVCodecContext parameters to those of the sprites
799                 avctx->width  = avctx->coded_width  = v->sprite_width;
800                 avctx->height = avctx->coded_height = v->sprite_height;
801             } else {
802                 goto image;
803             }
804         }
805     }
806
807     if (s->context_initialized &&
808         (s->width  != avctx->coded_width ||
809          s->height != avctx->coded_height)) {
810         ff_vc1_decode_end(avctx);
811     }
812
813     if (!s->context_initialized) {
814         if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
815             goto err;
816         if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
817             ff_mpv_common_end(s);
818             goto err;
819         }
820
821         s->low_delay = !avctx->has_b_frames || v->res_sprite;
822
823         if (v->profile == PROFILE_ADVANCED) {
824             if(avctx->coded_width<=1 || avctx->coded_height<=1) {
825                 ret = AVERROR_INVALIDDATA;
826                 goto err;
827             }
828             s->h_edge_pos = avctx->coded_width;
829             s->v_edge_pos = avctx->coded_height;
830         }
831     }
832
833     // do parse frame header
834     v->pic_header_flag = 0;
835     v->first_pic_header_flag = 1;
836     if (v->profile < PROFILE_ADVANCED) {
837         if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
838             goto err;
839         }
840     } else {
841         if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
842             goto err;
843         }
844     }
845     v->first_pic_header_flag = 0;
846
847     if (avctx->debug & FF_DEBUG_PICT_INFO)
848         av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
849
850     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
851         && s->pict_type != AV_PICTURE_TYPE_I) {
852         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
853         ret = AVERROR_INVALIDDATA;
854         goto err;
855     }
856
857     if ((s->mb_height >> v->field_mode) == 0) {
858         av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
859         ret = AVERROR_INVALIDDATA;
860         goto err;
861     }
862
863     // for skipping the frame
864     s->current_picture.f->pict_type = s->pict_type;
865     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
866
867     /* skip B-frames if we don't have reference frames */
868     if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
869         av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
870         goto end;
871     }
872     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
873         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
874          avctx->skip_frame >= AVDISCARD_ALL) {
875         goto end;
876     }
877
878     if (s->next_p_frame_damaged) {
879         if (s->pict_type == AV_PICTURE_TYPE_B)
880             goto end;
881         else
882             s->next_p_frame_damaged = 0;
883     }
884
885     if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
886         goto err;
887     }
888
889     v->s.current_picture_ptr->field_picture = v->field_mode;
890     v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
891     v->s.current_picture_ptr->f->top_field_first  = v->tff;
892
893     // process pulldown flags
894     s->current_picture_ptr->f->repeat_pict = 0;
895     // Pulldown flags are only valid when 'broadcast' has been set.
896     // So ticks_per_frame will be 2
897     if (v->rff) {
898         // repeat field
899         s->current_picture_ptr->f->repeat_pict = 1;
900     } else if (v->rptfrm) {
901         // repeat frames
902         s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
903     }
904
905     s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
906     s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
907
908 #if FF_API_CAP_VDPAU
909     if ((CONFIG_VC1_VDPAU_DECODER)
910         &&s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
911         if (v->field_mode && buf_start_second_field) {
912             ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
913             ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
914         } else {
915             ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
916         }
917     } else
918 #endif
919     if (avctx->hwaccel) {
920         if (v->field_mode && buf_start_second_field) {
921             // decode first field
922             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
923             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
924                 goto err;
925             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
926                 goto err;
927             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
928                 goto err;
929
930             // decode second field
931             s->gb = slices[n_slices1 + 1].gb;
932             s->picture_structure = PICT_TOP_FIELD + v->tff;
933             v->second_field = 1;
934             v->pic_header_flag = 0;
935             if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
936                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
937                 ret = AVERROR_INVALIDDATA;
938                 goto err;
939             }
940             v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
941
942             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
943                 goto err;
944             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
945                 goto err;
946             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
947                 goto err;
948         } else {
949             s->picture_structure = PICT_FRAME;
950             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
951                 goto err;
952             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
953                 goto err;
954             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
955                 goto err;
956         }
957     } else {
958         int header_ret = 0;
959
960         ff_mpeg_er_frame_start(s);
961
962         v->bits = buf_size * 8;
963         v->end_mb_x = s->mb_width;
964         if (v->field_mode) {
965             s->current_picture.f->linesize[0] <<= 1;
966             s->current_picture.f->linesize[1] <<= 1;
967             s->current_picture.f->linesize[2] <<= 1;
968             s->linesize                      <<= 1;
969             s->uvlinesize                    <<= 1;
970         }
971         mb_height = s->mb_height >> v->field_mode;
972
973         av_assert0 (mb_height > 0);
974
975         for (i = 0; i <= n_slices; i++) {
976             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
977                 if (v->field_mode <= 0) {
978                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
979                            "picture boundary (%d >= %d)\n", i,
980                            slices[i - 1].mby_start, mb_height);
981                     continue;
982                 }
983                 v->second_field = 1;
984                 av_assert0((s->mb_height & 1) == 0);
985                 v->blocks_off   = s->b8_stride * (s->mb_height&~1);
986                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
987             } else {
988                 v->second_field = 0;
989                 v->blocks_off   = 0;
990                 v->mb_off       = 0;
991             }
992             if (i) {
993                 v->pic_header_flag = 0;
994                 if (v->field_mode && i == n_slices1 + 2) {
995                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
996                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
997                         ret = AVERROR_INVALIDDATA;
998                         if (avctx->err_recognition & AV_EF_EXPLODE)
999                             goto err;
1000                         continue;
1001                     }
1002                 } else if (get_bits1(&s->gb)) {
1003                     v->pic_header_flag = 1;
1004                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1005                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1006                         ret = AVERROR_INVALIDDATA;
1007                         if (avctx->err_recognition & AV_EF_EXPLODE)
1008                             goto err;
1009                         continue;
1010                     }
1011                 }
1012             }
1013             if (header_ret < 0)
1014                 continue;
1015             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1016             if (!v->field_mode || v->second_field)
1017                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1018             else {
1019                 if (i >= n_slices) {
1020                     av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1021                     continue;
1022                 }
1023                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1024             }
1025             if (s->end_mb_y <= s->start_mb_y) {
1026                 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1027                 continue;
1028             }
1029             if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
1030                 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1031                 continue;
1032             }
1033             ff_vc1_decode_blocks(v);
1034             if (i != n_slices)
1035                 s->gb = slices[i].gb;
1036         }
1037         if (v->field_mode) {
1038             v->second_field = 0;
1039             s->current_picture.f->linesize[0] >>= 1;
1040             s->current_picture.f->linesize[1] >>= 1;
1041             s->current_picture.f->linesize[2] >>= 1;
1042             s->linesize                      >>= 1;
1043             s->uvlinesize                    >>= 1;
1044             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1045                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1046                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1047             }
1048         }
1049         ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1050                 get_bits_count(&s->gb), s->gb.size_in_bits);
1051 //  if (get_bits_count(&s->gb) > buf_size * 8)
1052 //      return -1;
1053         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1054             ret = AVERROR_INVALIDDATA;
1055             goto err;
1056         }
1057         if (!v->field_mode)
1058             ff_er_frame_end(&s->er);
1059     }
1060
1061     ff_mpv_frame_end(s);
1062
1063     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1064 image:
1065         avctx->width  = avctx->coded_width  = v->output_width;
1066         avctx->height = avctx->coded_height = v->output_height;
1067         if (avctx->skip_frame >= AVDISCARD_NONREF)
1068             goto end;
1069 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1070         if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1071             goto err;
1072 #endif
1073         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1074             goto err;
1075         *got_frame = 1;
1076     } else {
1077         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1078             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1079                 goto err;
1080             ff_print_debug_info(s, s->current_picture_ptr, pict);
1081             *got_frame = 1;
1082         } else if (s->last_picture_ptr) {
1083             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1084                 goto err;
1085             ff_print_debug_info(s, s->last_picture_ptr, pict);
1086             *got_frame = 1;
1087         }
1088     }
1089
1090 end:
1091     av_free(buf2);
1092     for (i = 0; i < n_slices; i++)
1093         av_free(slices[i].buf);
1094     av_free(slices);
1095     return buf_size;
1096
1097 err:
1098     av_free(buf2);
1099     for (i = 0; i < n_slices; i++)
1100         av_free(slices[i].buf);
1101     av_free(slices);
1102     return ret;
1103 }
1104
1105
1106 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1107 #if CONFIG_VC1_DXVA2_HWACCEL
1108     AV_PIX_FMT_DXVA2_VLD,
1109 #endif
1110 #if CONFIG_VC1_D3D11VA_HWACCEL
1111     AV_PIX_FMT_D3D11VA_VLD,
1112 #endif
1113 #if CONFIG_VC1_VAAPI_HWACCEL
1114     AV_PIX_FMT_VAAPI,
1115 #endif
1116 #if CONFIG_VC1_VDPAU_HWACCEL
1117     AV_PIX_FMT_VDPAU,
1118 #endif
1119     AV_PIX_FMT_YUV420P,
1120     AV_PIX_FMT_NONE
1121 };
1122
1123 AVCodec ff_vc1_decoder = {
1124     .name           = "vc1",
1125     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1126     .type           = AVMEDIA_TYPE_VIDEO,
1127     .id             = AV_CODEC_ID_VC1,
1128     .priv_data_size = sizeof(VC1Context),
1129     .init           = vc1_decode_init,
1130     .close          = ff_vc1_decode_end,
1131     .decode         = vc1_decode_frame,
1132     .flush          = ff_mpeg_flush,
1133     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1134     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1135     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1136 };
1137
1138 #if CONFIG_WMV3_DECODER
1139 AVCodec ff_wmv3_decoder = {
1140     .name           = "wmv3",
1141     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1142     .type           = AVMEDIA_TYPE_VIDEO,
1143     .id             = AV_CODEC_ID_WMV3,
1144     .priv_data_size = sizeof(VC1Context),
1145     .init           = vc1_decode_init,
1146     .close          = ff_vc1_decode_end,
1147     .decode         = vc1_decode_frame,
1148     .flush          = ff_mpeg_flush,
1149     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1150     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1151     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1152 };
1153 #endif
1154
1155 #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
1156 AVCodec ff_wmv3_vdpau_decoder = {
1157     .name           = "wmv3_vdpau",
1158     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
1159     .type           = AVMEDIA_TYPE_VIDEO,
1160     .id             = AV_CODEC_ID_WMV3,
1161     .priv_data_size = sizeof(VC1Context),
1162     .init           = vc1_decode_init,
1163     .close          = ff_vc1_decode_end,
1164     .decode         = vc1_decode_frame,
1165     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1166     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
1167     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1168 };
1169 #endif
1170
1171 #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
1172 AVCodec ff_vc1_vdpau_decoder = {
1173     .name           = "vc1_vdpau",
1174     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
1175     .type           = AVMEDIA_TYPE_VIDEO,
1176     .id             = AV_CODEC_ID_VC1,
1177     .priv_data_size = sizeof(VC1Context),
1178     .init           = vc1_decode_init,
1179     .close          = ff_vc1_decode_end,
1180     .decode         = vc1_decode_frame,
1181     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
1182     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
1183     .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1184 };
1185 #endif
1186
1187 #if CONFIG_WMV3IMAGE_DECODER
1188 AVCodec ff_wmv3image_decoder = {
1189     .name           = "wmv3image",
1190     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1191     .type           = AVMEDIA_TYPE_VIDEO,
1192     .id             = AV_CODEC_ID_WMV3IMAGE,
1193     .priv_data_size = sizeof(VC1Context),
1194     .init           = vc1_decode_init,
1195     .close          = ff_vc1_decode_end,
1196     .decode         = vc1_decode_frame,
1197     .capabilities   = AV_CODEC_CAP_DR1,
1198     .flush          = vc1_sprite_flush,
1199     .pix_fmts       = (const enum AVPixelFormat[]) {
1200         AV_PIX_FMT_YUV420P,
1201         AV_PIX_FMT_NONE
1202     },
1203 };
1204 #endif
1205
1206 #if CONFIG_VC1IMAGE_DECODER
1207 AVCodec ff_vc1image_decoder = {
1208     .name           = "vc1image",
1209     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1210     .type           = AVMEDIA_TYPE_VIDEO,
1211     .id             = AV_CODEC_ID_VC1IMAGE,
1212     .priv_data_size = sizeof(VC1Context),
1213     .init           = vc1_decode_init,
1214     .close          = ff_vc1_decode_end,
1215     .decode         = vc1_decode_frame,
1216     .capabilities   = AV_CODEC_CAP_DR1,
1217     .flush          = vc1_sprite_flush,
1218     .pix_fmts       = (const enum AVPixelFormat[]) {
1219         AV_PIX_FMT_YUV420P,
1220         AV_PIX_FMT_NONE
1221     },
1222 };
1223 #endif