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