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