GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vc1dec.c Lines: 329 753 43.7 %
Date: 2020-09-25 14:59:26 Branches: 192 538 35.7 %

Line Branch Exec Source
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 "hwconfig.h"
33
#include "internal.h"
34
#include "mpeg_er.h"
35
#include "mpegvideo.h"
36
#include "msmpeg4.h"
37
#include "msmpeg4data.h"
38
#include "profiles.h"
39
#include "vc1.h"
40
#include "vc1data.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
42
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
325
{
326
42
    MpegEncContext *s = &v->s;
327
42
    int i, ret = AVERROR(ENOMEM);
328
42
    int mb_height = FFALIGN(s->mb_height, 2);
329
330
    /* Allocate mb bitplanes */
331
42
    v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
332
42
    v->direct_mb_plane  = av_malloc (s->mb_stride * mb_height);
333
42
    v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
334
42
    v->fieldtx_plane    = av_mallocz(s->mb_stride * mb_height);
335
42
    v->acpred_plane     = av_malloc (s->mb_stride * mb_height);
336
42
    v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
337

42
    if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
338

42
        !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
339
        goto error;
340
341
42
    v->n_allocated_blks = s->mb_width + 2;
342
42
    v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
343
42
    v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
344

42
    if (!v->block || !v->cbp_base)
345
        goto error;
346
42
    v->cbp              = v->cbp_base + 2 * s->mb_stride;
347
42
    v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
348
42
    if (!v->ttblk_base)
349
        goto error;
350
42
    v->ttblk            = v->ttblk_base + 2 * s->mb_stride;
351
42
    v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
352
42
    if (!v->is_intra_base)
353
        goto error;
354
42
    v->is_intra         = v->is_intra_base + 2 * s->mb_stride;
355
42
    v->luma_mv_base     = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
356
42
    if (!v->luma_mv_base)
357
        goto error;
358
42
    v->luma_mv          = v->luma_mv_base + 2 * s->mb_stride;
359
360
    /* allocate block type info in that way so it could be used with s->block_index[] */
361
42
    v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362
42
    if (!v->mb_type_base)
363
        goto error;
364
42
    v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
365
42
    v->mb_type[1]   = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366
42
    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
42
    v->blk_mv_type_base = av_mallocz(     s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370
42
    if (!v->blk_mv_type_base)
371
        goto error;
372
42
    v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
373
42
    v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
374
42
    if (!v->mv_f_base)
375
        goto error;
376
42
    v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
377
42
    v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378
42
    v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379
42
    if (!v->mv_f_next_base)
380
        goto error;
381
42
    v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
382
42
    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

42
    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
42
    ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp,
391
42
                                 s->block, s->block_last_index,
392
                                 s->mb_width, s->mb_height);
393
42
    if (ret < 0)
394
        goto error;
395
396
42
    return 0;
397
398
error:
399
    ff_vc1_decode_end(s->avctx);
400
    return ret;
401
}
402
403
32
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
404
{
405
    int i;
406
2080
    for (i = 0; i < 64; i++) {
407
#define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
408
2048
        v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
409
2048
        v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
410
2048
        v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
411
2048
        v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
412
2048
        v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
413
    }
414
32
    v->left_blk_sh = 0;
415
32
    v->top_blk_sh  = 3;
416
32
}
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
28
static av_cold int vc1_decode_init(AVCodecContext *avctx)
423
{
424
28
    VC1Context *v = avctx->priv_data;
425
28
    MpegEncContext *s = &v->s;
426
    GetBitContext gb;
427
    int ret;
428
429
    /* save the container output size for WMImage */
430
28
    v->output_width  = avctx->width;
431
28
    v->output_height = avctx->height;
432
433

28
    if (!avctx->extradata_size || !avctx->extradata)
434
6
        return AVERROR_INVALIDDATA;
435
22
    v->s.avctx = avctx;
436
437
22
    if ((ret = ff_vc1_init_common(v)) < 0)
438
        return ret;
439
440

29
    if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
441
7
        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
7
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
449
450
7
        if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
451
          return ret;
452
453

7
        if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
454
            avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
455
            return AVERROR_PATCHWELCOME;
456
        }
457
458
7
        count = avctx->extradata_size*8 - get_bits_count(&gb);
459
7
        if (count > 0) {
460
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
461
                   count, get_bits_long(&gb, FFMIN(count, 32)));
462
7
        } else if (count < 0) {
463
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
464
        }
465
    } else { // VC1/WVC1/WVP2
466
15
        const uint8_t *start = avctx->extradata;
467
15
        uint8_t *end = avctx->extradata + avctx->extradata_size;
468
        const uint8_t *next;
469
        int size, buf2_size;
470
15
        uint8_t *buf2 = NULL;
471
15
        int seq_initialized = 0, ep_initialized = 0;
472
473
15
        if (avctx->extradata_size < 16) {
474
            av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
475
            return AVERROR_INVALIDDATA;
476
        }
477
478
15
        buf2  = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
479
15
        if (!buf2)
480
            return AVERROR(ENOMEM);
481
482
15
        start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
483
15
        next  = start;
484
55
        for (; next < end; start = next) {
485
40
            next = find_next_marker(start + 4, end);
486
40
            size = next - start - 4;
487
40
            if (size <= 0)
488
                continue;
489
40
            buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
490
40
            init_get_bits(&gb, buf2, buf2_size * 8);
491
40
            switch (AV_RB32(start)) {
492
15
            case VC1_CODE_SEQHDR:
493
15
                if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
494
                    av_free(buf2);
495
                    return ret;
496
                }
497
15
                seq_initialized = 1;
498
15
                break;
499
25
            case VC1_CODE_ENTRYPOINT:
500
25
                if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
501
                    av_free(buf2);
502
                    return ret;
503
                }
504
25
                ep_initialized = 1;
505
25
                break;
506
            }
507
40
        }
508
15
        av_free(buf2);
509

15
        if (!seq_initialized || !ep_initialized) {
510
            av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
511
            return AVERROR_INVALIDDATA;
512
        }
513
15
        v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
514
    }
515
516
22
    avctx->profile = v->profile;
517
22
    if (v->profile == PROFILE_ADVANCED)
518
15
        avctx->level = v->level;
519
520
    if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
521
22
        avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
522
    else {
523
        avctx->pix_fmt = AV_PIX_FMT_GRAY8;
524
        if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
525
            avctx->color_range = AVCOL_RANGE_MPEG;
526
    }
527
528
    // ensure static VLC tables are initialized
529
22
    if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
530
        return ret;
531
22
    if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
532
        return ret;
533
    // Hack to ensure the above functions will be called
534
    // again once we know all necessary settings.
535
    // That this is necessary might indicate a bug.
536
22
    ff_vc1_decode_end(avctx);
537
538
22
    ff_blockdsp_init(&s->bdsp, avctx);
539
22
    ff_h264chroma_init(&v->h264chroma, 8);
540
22
    ff_qpeldsp_init(&s->qdsp);
541
542
    // Must happen after calling ff_vc1_decode_end
543
    // to avoid de-allocating the sprite_output_frame
544
22
    v->sprite_output_frame = av_frame_alloc();
545
22
    if (!v->sprite_output_frame)
546
        return AVERROR(ENOMEM);
547
548
22
    avctx->has_b_frames = !!avctx->max_b_frames;
549
550

22
    if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
551
        avctx->color_primaries = v->color_prim;
552

22
    if (v->transfer_char == 1 || v->transfer_char == 7)
553
        avctx->color_trc = v->transfer_char;
554

22
    if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
555
        avctx->colorspace = v->matrix_coef;
556
557
22
    s->mb_width  = (avctx->coded_width  + 15) >> 4;
558
22
    s->mb_height = (avctx->coded_height + 15) >> 4;
559
560

22
    if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
561
22
        ff_vc1_init_transposed_scantables(v);
562
    } else {
563
        memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
564
        v->left_blk_sh = 3;
565
        v->top_blk_sh  = 0;
566
    }
567
568

22
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
569
        v->sprite_width  = avctx->coded_width;
570
        v->sprite_height = avctx->coded_height;
571
572
        avctx->coded_width  = avctx->width  = v->output_width;
573
        avctx->coded_height = avctx->height = v->output_height;
574
575
        // prevent 16.16 overflows
576
        if (v->sprite_width  > 1 << 14 ||
577
            v->sprite_height > 1 << 14 ||
578
            v->output_width  > 1 << 14 ||
579
            v->output_height > 1 << 14) {
580
            ret = AVERROR_INVALIDDATA;
581
            goto error;
582
        }
583
584
        if ((v->sprite_width&1) || (v->sprite_height&1)) {
585
            avpriv_request_sample(avctx, "odd sprites support");
586
            ret = AVERROR_PATCHWELCOME;
587
            goto error;
588
        }
589
    }
590
22
    return 0;
591
error:
592
    av_frame_free(&v->sprite_output_frame);
593
    return ret;
594
}
595
596
/** Close a VC1/WMV3 decoder
597
 * @warning Initial try at using MpegEncContext stuff
598
 */
599
54
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
600
{
601
54
    VC1Context *v = avctx->priv_data;
602
    int i;
603
604
54
    av_frame_free(&v->sprite_output_frame);
605
606
270
    for (i = 0; i < 4; i++)
607
216
        av_freep(&v->sr_rows[i >> 1][i & 1]);
608
54
    av_freep(&v->hrd_rate);
609
54
    av_freep(&v->hrd_buffer);
610
54
    ff_mpv_common_end(&v->s);
611
54
    av_freep(&v->mv_type_mb_plane);
612
54
    av_freep(&v->direct_mb_plane);
613
54
    av_freep(&v->forward_mb_plane);
614
54
    av_freep(&v->fieldtx_plane);
615
54
    av_freep(&v->acpred_plane);
616
54
    av_freep(&v->over_flags_plane);
617
54
    av_freep(&v->mb_type_base);
618
54
    av_freep(&v->blk_mv_type_base);
619
54
    av_freep(&v->mv_f_base);
620
54
    av_freep(&v->mv_f_next_base);
621
54
    av_freep(&v->block);
622
54
    av_freep(&v->cbp_base);
623
54
    av_freep(&v->ttblk_base);
624
54
    av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
625
54
    av_freep(&v->luma_mv_base);
626
54
    ff_intrax8_common_end(&v->x8);
627
54
    return 0;
628
}
629
630
631
/** Decode a VC1/WMV3 frame
632
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
633
 */
634
494
static int vc1_decode_frame(AVCodecContext *avctx, void *data,
635
                            int *got_frame, AVPacket *avpkt)
636
{
637
494
    const uint8_t *buf = avpkt->data;
638
494
    int buf_size = avpkt->size, n_slices = 0, i, ret;
639
494
    VC1Context *v = avctx->priv_data;
640
494
    MpegEncContext *s = &v->s;
641
494
    AVFrame *pict = data;
642
494
    uint8_t *buf2 = NULL;
643
494
    const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
644
494
    int mb_height, n_slices1=-1;
645
    struct {
646
        uint8_t *buf;
647
        GetBitContext gb;
648
        int mby_start;
649
        const uint8_t *rawbuf;
650
        int raw_size;
651
494
    } *slices = NULL, *tmp;
652
653
494
    v->second_field = 0;
654
655
494
    if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
656
        s->low_delay = 1;
657
658
    /* no supplementary picture */
659

494
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
660
        /* special case for last picture */
661

18
        if (s->low_delay == 0 && s->next_picture_ptr) {
662
8
            if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
663
                return ret;
664
8
            s->next_picture_ptr = NULL;
665
666
8
            *got_frame = 1;
667
        }
668
669
18
        return buf_size;
670
    }
671
672
    //for advanced profile we may need to parse and unescape data
673

774
    if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
674
298
        int buf_size2 = 0;
675
298
        buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
676
298
        if (!buf2)
677
            return AVERROR(ENOMEM);
678
679
298
        if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
680
            const uint8_t *start, *end, *next;
681
            int size;
682
683
298
            next = buf;
684
1250
            for (start = buf, end = buf + buf_size; next < end; start = next) {
685
952
                next = find_next_marker(start + 4, end);
686
952
                size = next - start - 4;
687
952
                if (size <= 0) continue;
688

952
                switch (AV_RB32(start)) {
689
298
                case VC1_CODE_FRAME:
690
298
                    if (avctx->hwaccel)
691
                        buf_start = start;
692
298
                    buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
693
298
                    break;
694
36
                case VC1_CODE_FIELD: {
695
                    int buf_size3;
696
36
                    if (avctx->hwaccel)
697
                        buf_start_second_field = start;
698
36
                    tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
699
36
                    if (!tmp) {
700
                        ret = AVERROR(ENOMEM);
701
                        goto err;
702
                    }
703
36
                    slices = tmp;
704
36
                    slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
705
36
                    if (!slices[n_slices].buf) {
706
                        ret = AVERROR(ENOMEM);
707
                        goto err;
708
                    }
709
36
                    buf_size3 = vc1_unescape_buffer(start + 4, size,
710
36
                                                    slices[n_slices].buf);
711
36
                    init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
712
                                  buf_size3 << 3);
713
36
                    slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
714
36
                    slices[n_slices].rawbuf = start;
715
36
                    slices[n_slices].raw_size = size + 4;
716
36
                    n_slices1 = n_slices - 1; // index of the last slice of the first field
717
36
                    n_slices++;
718
36
                    break;
719
                }
720
13
                case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
721
13
                    buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
722
13
                    init_get_bits(&s->gb, buf2, buf_size2 * 8);
723
13
                    ff_vc1_decode_entry_point(avctx, v, &s->gb);
724
13
                    break;
725
597
                case VC1_CODE_SLICE: {
726
                    int buf_size3;
727
597
                    tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
728
597
                    if (!tmp) {
729
                        ret = AVERROR(ENOMEM);
730
                        goto err;
731
                    }
732
597
                    slices = tmp;
733
597
                    slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
734
597
                    if (!slices[n_slices].buf) {
735
                        ret = AVERROR(ENOMEM);
736
                        goto err;
737
                    }
738
597
                    buf_size3 = vc1_unescape_buffer(start + 4, size,
739
597
                                                    slices[n_slices].buf);
740
597
                    init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
741
                                  buf_size3 << 3);
742
597
                    slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
743
597
                    slices[n_slices].rawbuf = start;
744
597
                    slices[n_slices].raw_size = size + 4;
745
597
                    n_slices++;
746
597
                    break;
747
                }
748
                }
749
952
            }
750
        } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
751
            const uint8_t *divider;
752
            int buf_size3;
753
754
            divider = find_next_marker(buf, buf + buf_size);
755
            if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
756
                av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
757
                ret = AVERROR_INVALIDDATA;
758
                goto err;
759
            } else { // found field marker, unescape second field
760
                if (avctx->hwaccel)
761
                    buf_start_second_field = divider;
762
                tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
763
                if (!tmp) {
764
                    ret = AVERROR(ENOMEM);
765
                    goto err;
766
                }
767
                slices = tmp;
768
                slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
769
                if (!slices[n_slices].buf) {
770
                    ret = AVERROR(ENOMEM);
771
                    goto err;
772
                }
773
                buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
774
                init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
775
                              buf_size3 << 3);
776
                slices[n_slices].mby_start = s->mb_height + 1 >> 1;
777
                slices[n_slices].rawbuf = divider;
778
                slices[n_slices].raw_size = buf + buf_size - divider;
779
                n_slices1 = n_slices - 1;
780
                n_slices++;
781
            }
782
            buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
783
        } else {
784
            buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
785
        }
786
298
        init_get_bits(&s->gb, buf2, buf_size2*8);
787
    } else
788
178
        init_get_bits(&s->gb, buf, buf_size*8);
789
790
476
    if (v->res_sprite) {
791
        v->new_sprite  = !get_bits1(&s->gb);
792
        v->two_sprites =  get_bits1(&s->gb);
793
        /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
794
           we're using the sprite compositor. These are intentionally kept separate
795
           so you can get the raw sprites by using the wmv3 decoder for WMVP or
796
           the vc1 one for WVP2 */
797
        if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
798
            if (v->new_sprite) {
799
                // switch AVCodecContext parameters to those of the sprites
800
                avctx->width  = avctx->coded_width  = v->sprite_width;
801
                avctx->height = avctx->coded_height = v->sprite_height;
802
            } else {
803
                goto image;
804
            }
805
        }
806
    }
807
808
476
    if (s->context_initialized &&
809
466
        (s->width  != avctx->coded_width ||
810
466
         s->height != avctx->coded_height)) {
811
        ff_vc1_decode_end(avctx);
812
    }
813
814
476
    if (!s->context_initialized) {
815
10
        if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
816
            goto err;
817
10
        if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
818
            ff_mpv_common_end(s);
819
            goto err;
820
        }
821
822

10
        s->low_delay = !avctx->has_b_frames || v->res_sprite;
823
824
10
        if (v->profile == PROFILE_ADVANCED) {
825

7
            if(avctx->coded_width<=1 || avctx->coded_height<=1) {
826
                ret = AVERROR_INVALIDDATA;
827
                goto err;
828
            }
829
7
            s->h_edge_pos = avctx->coded_width;
830
7
            s->v_edge_pos = avctx->coded_height;
831
        }
832
    }
833
834
    // do parse frame header
835
476
    v->pic_header_flag = 0;
836
476
    v->first_pic_header_flag = 1;
837
476
    if (v->profile < PROFILE_ADVANCED) {
838
178
        if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
839
            goto err;
840
        }
841
    } else {
842
298
        if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
843
            goto err;
844
        }
845
    }
846
476
    v->first_pic_header_flag = 0;
847
848
476
    if (avctx->debug & FF_DEBUG_PICT_INFO)
849
        av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
850
851

476
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
852
        && s->pict_type != AV_PICTURE_TYPE_I) {
853
        av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
854
        ret = AVERROR_INVALIDDATA;
855
        goto err;
856
    }
857

476
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
858
        && v->field_mode) {
859
        av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
860
        ret = AVERROR_INVALIDDATA;
861
        goto err;
862
    }
863
476
    if ((s->mb_height >> v->field_mode) == 0) {
864
        av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
865
        ret = AVERROR_INVALIDDATA;
866
        goto err;
867
    }
868
869
    // for skipping the frame
870
476
    s->current_picture.f->pict_type = s->pict_type;
871
476
    s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
872
873
    /* skip B-frames if we don't have reference frames */
874

476
    if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
875
        av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
876
        goto end;
877
    }
878

476
    if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
879

476
        (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
880
476
         avctx->skip_frame >= AVDISCARD_ALL) {
881
        goto end;
882
    }
883
884
476
    if (s->next_p_frame_damaged) {
885
        if (s->pict_type == AV_PICTURE_TYPE_B)
886
            goto end;
887
        else
888
            s->next_p_frame_damaged = 0;
889
    }
890
891
476
    if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
892
        goto err;
893
    }
894
895
476
    v->s.current_picture_ptr->field_picture = v->field_mode;
896
476
    v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
897
476
    v->s.current_picture_ptr->f->top_field_first  = v->tff;
898
899
    // process pulldown flags
900
476
    s->current_picture_ptr->f->repeat_pict = 0;
901
    // Pulldown flags are only valid when 'broadcast' has been set.
902
    // So ticks_per_frame will be 2
903
476
    if (v->rff) {
904
        // repeat field
905
        s->current_picture_ptr->f->repeat_pict = 1;
906
476
    } else if (v->rptfrm) {
907
        // repeat frames
908
        s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
909
    }
910
911
476
    s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
912
476
    s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
913
914
476
    if (avctx->hwaccel) {
915
        s->mb_y = 0;
916
        if (v->field_mode && buf_start_second_field) {
917
            // decode first field
918
            s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
919
            if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
920
                goto err;
921
922
            if (n_slices1 == -1) {
923
                // no slices, decode the field as-is
924
                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
925
                    goto err;
926
            } else {
927
                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
928
                    goto err;
929
930
                for (i = 0 ; i < n_slices1 + 1; i++) {
931
                    s->gb = slices[i].gb;
932
                    s->mb_y = slices[i].mby_start;
933
934
                    v->pic_header_flag = get_bits1(&s->gb);
935
                    if (v->pic_header_flag) {
936
                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
937
                            av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
938
                            ret = AVERROR_INVALIDDATA;
939
                            if (avctx->err_recognition & AV_EF_EXPLODE)
940
                                goto err;
941
                            continue;
942
                        }
943
                    }
944
945
                    if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
946
                        goto err;
947
                }
948
            }
949
950
            if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
951
                goto err;
952
953
            // decode second field
954
            s->gb = slices[n_slices1 + 1].gb;
955
            s->mb_y = slices[n_slices1 + 1].mby_start;
956
            s->picture_structure = PICT_TOP_FIELD + v->tff;
957
            v->second_field = 1;
958
            v->pic_header_flag = 0;
959
            if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
960
                av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
961
                ret = AVERROR_INVALIDDATA;
962
                goto err;
963
            }
964
            v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
965
966
            if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
967
                goto err;
968
969
            if (n_slices - n_slices1 == 2) {
970
                // no slices, decode the field as-is
971
                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
972
                    goto err;
973
            } else {
974
                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
975
                    goto err;
976
977
                for (i = n_slices1 + 2; i < n_slices; i++) {
978
                    s->gb = slices[i].gb;
979
                    s->mb_y = slices[i].mby_start;
980
981
                    v->pic_header_flag = get_bits1(&s->gb);
982
                    if (v->pic_header_flag) {
983
                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
984
                            av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
985
                            ret = AVERROR_INVALIDDATA;
986
                            if (avctx->err_recognition & AV_EF_EXPLODE)
987
                                goto err;
988
                            continue;
989
                        }
990
                    }
991
992
                    if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
993
                        goto err;
994
                }
995
            }
996
997
            if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
998
                goto err;
999
        } else {
1000
            s->picture_structure = PICT_FRAME;
1001
            if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1002
                goto err;
1003
1004
            if (n_slices == 0) {
1005
                // no slices, decode the frame as-is
1006
                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1007
                    goto err;
1008
            } else {
1009
                // decode the frame part as the first slice
1010
                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1011
                    goto err;
1012
1013
                // and process the slices as additional slices afterwards
1014
                for (i = 0 ; i < n_slices; i++) {
1015
                    s->gb = slices[i].gb;
1016
                    s->mb_y = slices[i].mby_start;
1017
1018
                    v->pic_header_flag = get_bits1(&s->gb);
1019
                    if (v->pic_header_flag) {
1020
                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1021
                            av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1022
                            ret = AVERROR_INVALIDDATA;
1023
                            if (avctx->err_recognition & AV_EF_EXPLODE)
1024
                                goto err;
1025
                            continue;
1026
                        }
1027
                    }
1028
1029
                    if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1030
                        goto err;
1031
                }
1032
            }
1033
            if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1034
                goto err;
1035
        }
1036
    } else {
1037
476
        int header_ret = 0;
1038
1039
476
        ff_mpeg_er_frame_start(s);
1040
1041
476
        v->end_mb_x = s->mb_width;
1042
476
        if (v->field_mode) {
1043
36
            s->current_picture.f->linesize[0] <<= 1;
1044
36
            s->current_picture.f->linesize[1] <<= 1;
1045
36
            s->current_picture.f->linesize[2] <<= 1;
1046
36
            s->linesize                      <<= 1;
1047
36
            s->uvlinesize                    <<= 1;
1048
        }
1049
476
        mb_height = s->mb_height >> v->field_mode;
1050
1051
476
        av_assert0 (mb_height > 0);
1052
1053
1585
        for (i = 0; i <= n_slices; i++) {
1054

1109
            if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
1055
36
                if (v->field_mode <= 0) {
1056
                    av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1057
                           "picture boundary (%d >= %d)\n", i,
1058
                           slices[i - 1].mby_start, mb_height);
1059
                    continue;
1060
                }
1061
36
                v->second_field = 1;
1062
36
                av_assert0((s->mb_height & 1) == 0);
1063
36
                v->blocks_off   = s->b8_stride * (s->mb_height&~1);
1064
36
                v->mb_off       = s->mb_stride * s->mb_height >> 1;
1065
            } else {
1066
1073
                v->second_field = 0;
1067
1073
                v->blocks_off   = 0;
1068
1073
                v->mb_off       = 0;
1069
            }
1070
1109
            if (i) {
1071
633
                v->pic_header_flag = 0;
1072

633
                if (v->field_mode && i == n_slices1 + 2) {
1073
36
                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1074
                        av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1075
                        ret = AVERROR_INVALIDDATA;
1076
                        if (avctx->err_recognition & AV_EF_EXPLODE)
1077
                            goto err;
1078
                        continue;
1079
                    }
1080
597
                } else if (get_bits1(&s->gb)) {
1081
271
                    v->pic_header_flag = 1;
1082
271
                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1083
                        av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1084
                        ret = AVERROR_INVALIDDATA;
1085
                        if (avctx->err_recognition & AV_EF_EXPLODE)
1086
                            goto err;
1087
                        continue;
1088
                    }
1089
                }
1090
            }
1091
1109
            if (header_ret < 0)
1092
                continue;
1093
1109
            s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1094

1109
            if (!v->field_mode || v->second_field)
1095
1073
                s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1096
            else {
1097
36
                if (i >= n_slices) {
1098
                    av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1099
                    continue;
1100
                }
1101
36
                s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1102
            }
1103
1109
            if (s->end_mb_y <= s->start_mb_y) {
1104
                av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1105
                continue;
1106
            }
1107

1109
            if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1108

194
                 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1109
1024
                !v->cbpcy_vlc) {
1110
                av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1111
                continue;
1112
            }
1113
1109
            ff_vc1_decode_blocks(v);
1114
1109
            if (i != n_slices) {
1115
633
                s->gb = slices[i].gb;
1116
            }
1117
        }
1118
476
        if (v->field_mode) {
1119
36
            v->second_field = 0;
1120
36
            s->current_picture.f->linesize[0] >>= 1;
1121
36
            s->current_picture.f->linesize[1] >>= 1;
1122
36
            s->current_picture.f->linesize[2] >>= 1;
1123
36
            s->linesize                      >>= 1;
1124
36
            s->uvlinesize                    >>= 1;
1125

36
            if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1126
18
                FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1127
18
                FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1128
            }
1129
        }
1130
        ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1131
                get_bits_count(&s->gb), s->gb.size_in_bits);
1132
//  if (get_bits_count(&s->gb) > buf_size * 8)
1133
//      return -1;
1134

476
        if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1135
            ret = AVERROR_INVALIDDATA;
1136
            goto err;
1137
        }
1138
476
        if (!v->field_mode)
1139
440
            ff_er_frame_end(&s->er);
1140
    }
1141
1142
476
    ff_mpv_frame_end(s);
1143
1144

476
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1145
image:
1146
        avctx->width  = avctx->coded_width  = v->output_width;
1147
        avctx->height = avctx->coded_height = v->output_height;
1148
        if (avctx->skip_frame >= AVDISCARD_NONREF)
1149
            goto end;
1150
#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1151
        if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1152
            goto err;
1153
#endif
1154
        if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1155
            goto err;
1156
        *got_frame = 1;
1157
    } else {
1158

476
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1159
245
            if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1160
                goto err;
1161
245
            ff_print_debug_info(s, s->current_picture_ptr, pict);
1162
245
            *got_frame = 1;
1163
231
        } else if (s->last_picture_ptr) {
1164
223
            if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1165
                goto err;
1166
223
            ff_print_debug_info(s, s->last_picture_ptr, pict);
1167
223
            *got_frame = 1;
1168
        }
1169
    }
1170
1171
8
end:
1172
476
    av_free(buf2);
1173
1109
    for (i = 0; i < n_slices; i++)
1174
633
        av_free(slices[i].buf);
1175
476
    av_free(slices);
1176
476
    return buf_size;
1177
1178
err:
1179
    av_free(buf2);
1180
    for (i = 0; i < n_slices; i++)
1181
        av_free(slices[i].buf);
1182
    av_free(slices);
1183
    return ret;
1184
}
1185
1186
1187
static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1188
#if CONFIG_VC1_DXVA2_HWACCEL
1189
    AV_PIX_FMT_DXVA2_VLD,
1190
#endif
1191
#if CONFIG_VC1_D3D11VA_HWACCEL
1192
    AV_PIX_FMT_D3D11VA_VLD,
1193
    AV_PIX_FMT_D3D11,
1194
#endif
1195
#if CONFIG_VC1_NVDEC_HWACCEL
1196
    AV_PIX_FMT_CUDA,
1197
#endif
1198
#if CONFIG_VC1_VAAPI_HWACCEL
1199
    AV_PIX_FMT_VAAPI,
1200
#endif
1201
#if CONFIG_VC1_VDPAU_HWACCEL
1202
    AV_PIX_FMT_VDPAU,
1203
#endif
1204
    AV_PIX_FMT_YUV420P,
1205
    AV_PIX_FMT_NONE
1206
};
1207
1208
AVCodec ff_vc1_decoder = {
1209
    .name           = "vc1",
1210
    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1211
    .type           = AVMEDIA_TYPE_VIDEO,
1212
    .id             = AV_CODEC_ID_VC1,
1213
    .priv_data_size = sizeof(VC1Context),
1214
    .init           = vc1_decode_init,
1215
    .close          = ff_vc1_decode_end,
1216
    .decode         = vc1_decode_frame,
1217
    .flush          = ff_mpeg_flush,
1218
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1219
    .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1220
    .hw_configs     = (const AVCodecHWConfigInternal*[]) {
1221
#if CONFIG_VC1_DXVA2_HWACCEL
1222
                        HWACCEL_DXVA2(vc1),
1223
#endif
1224
#if CONFIG_VC1_D3D11VA_HWACCEL
1225
                        HWACCEL_D3D11VA(vc1),
1226
#endif
1227
#if CONFIG_VC1_D3D11VA2_HWACCEL
1228
                        HWACCEL_D3D11VA2(vc1),
1229
#endif
1230
#if CONFIG_VC1_NVDEC_HWACCEL
1231
                        HWACCEL_NVDEC(vc1),
1232
#endif
1233
#if CONFIG_VC1_VAAPI_HWACCEL
1234
                        HWACCEL_VAAPI(vc1),
1235
#endif
1236
#if CONFIG_VC1_VDPAU_HWACCEL
1237
                        HWACCEL_VDPAU(vc1),
1238
#endif
1239
                        NULL
1240
                    },
1241
    .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1242
};
1243
1244
#if CONFIG_WMV3_DECODER
1245
AVCodec ff_wmv3_decoder = {
1246
    .name           = "wmv3",
1247
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1248
    .type           = AVMEDIA_TYPE_VIDEO,
1249
    .id             = AV_CODEC_ID_WMV3,
1250
    .priv_data_size = sizeof(VC1Context),
1251
    .init           = vc1_decode_init,
1252
    .close          = ff_vc1_decode_end,
1253
    .decode         = vc1_decode_frame,
1254
    .flush          = ff_mpeg_flush,
1255
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1256
    .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
1257
    .hw_configs     = (const AVCodecHWConfigInternal*[]) {
1258
#if CONFIG_WMV3_DXVA2_HWACCEL
1259
                        HWACCEL_DXVA2(wmv3),
1260
#endif
1261
#if CONFIG_WMV3_D3D11VA_HWACCEL
1262
                        HWACCEL_D3D11VA(wmv3),
1263
#endif
1264
#if CONFIG_WMV3_D3D11VA2_HWACCEL
1265
                        HWACCEL_D3D11VA2(wmv3),
1266
#endif
1267
#if CONFIG_WMV3_NVDEC_HWACCEL
1268
                        HWACCEL_NVDEC(wmv3),
1269
#endif
1270
#if CONFIG_WMV3_VAAPI_HWACCEL
1271
                        HWACCEL_VAAPI(wmv3),
1272
#endif
1273
#if CONFIG_WMV3_VDPAU_HWACCEL
1274
                        HWACCEL_VDPAU(wmv3),
1275
#endif
1276
                        NULL
1277
                    },
1278
    .profiles       = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1279
};
1280
#endif
1281
1282
#if CONFIG_WMV3IMAGE_DECODER
1283
AVCodec ff_wmv3image_decoder = {
1284
    .name           = "wmv3image",
1285
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1286
    .type           = AVMEDIA_TYPE_VIDEO,
1287
    .id             = AV_CODEC_ID_WMV3IMAGE,
1288
    .priv_data_size = sizeof(VC1Context),
1289
    .init           = vc1_decode_init,
1290
    .close          = ff_vc1_decode_end,
1291
    .decode         = vc1_decode_frame,
1292
    .capabilities   = AV_CODEC_CAP_DR1,
1293
    .flush          = vc1_sprite_flush,
1294
    .pix_fmts       = (const enum AVPixelFormat[]) {
1295
        AV_PIX_FMT_YUV420P,
1296
        AV_PIX_FMT_NONE
1297
    },
1298
};
1299
#endif
1300
1301
#if CONFIG_VC1IMAGE_DECODER
1302
AVCodec ff_vc1image_decoder = {
1303
    .name           = "vc1image",
1304
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1305
    .type           = AVMEDIA_TYPE_VIDEO,
1306
    .id             = AV_CODEC_ID_VC1IMAGE,
1307
    .priv_data_size = sizeof(VC1Context),
1308
    .init           = vc1_decode_init,
1309
    .close          = ff_vc1_decode_end,
1310
    .decode         = vc1_decode_frame,
1311
    .capabilities   = AV_CODEC_CAP_DR1,
1312
    .flush          = vc1_sprite_flush,
1313
    .pix_fmts       = (const enum AVPixelFormat[]) {
1314
        AV_PIX_FMT_YUV420P,
1315
        AV_PIX_FMT_NONE
1316
    },
1317
};
1318
#endif