GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vc1dec.c Lines: 325 746 43.6 %
Date: 2021-04-14 23:45:22 Branches: 190 538 35.3 %

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
                goto error;
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
    ff_vc1_init_common(v);
438
439

29
    if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
440
7
        int count = 0;
441
442
        // looks like WMV3 has a sequence header stored in the extradata
443
        // advanced sequence header may be before the first frame
444
        // the last byte of the extradata is a version number, 1 for the
445
        // samples we can decode
446
447
7
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
448
449
7
        if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
450
          return ret;
451
452

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

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

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

22
    if (v->transfer_char == 1 || v->transfer_char == 7)
546
        avctx->color_trc = v->transfer_char;
547

22
    if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
548
        avctx->colorspace = v->matrix_coef;
549
550
22
    s->mb_width  = (avctx->coded_width  + 15) >> 4;
551
22
    s->mb_height = (avctx->coded_height + 15) >> 4;
552
553

22
    if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
554
22
        ff_vc1_init_transposed_scantables(v);
555
    } else {
556
        memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
557
        v->left_blk_sh = 3;
558
        v->top_blk_sh  = 0;
559
    }
560
561

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

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

18
        if (s->low_delay == 0 && s->next_picture_ptr) {
648
8
            if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
649
                return ret;
650
8
            s->next_picture_ptr = NULL;
651
652
8
            *got_frame = 1;
653
        }
654
655
18
        return buf_size;
656
    }
657
658
    //for advanced profile we may need to parse and unescape data
659

774
    if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
660
298
        int buf_size2 = 0;
661
298
        buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
662
298
        if (!buf2)
663
            return AVERROR(ENOMEM);
664
665
298
        if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
666
            const uint8_t *start, *end, *next;
667
            int size;
668
669
298
            next = buf;
670
1250
            for (start = buf, end = buf + buf_size; next < end; start = next) {
671
952
                next = find_next_marker(start + 4, end);
672
952
                size = next - start - 4;
673
952
                if (size <= 0) continue;
674

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

10
        s->low_delay = !avctx->has_b_frames || v->res_sprite;
809
810
10
        if (v->profile == PROFILE_ADVANCED) {
811

7
            if(avctx->coded_width<=1 || avctx->coded_height<=1) {
812
                ret = AVERROR_INVALIDDATA;
813
                goto err;
814
            }
815
7
            s->h_edge_pos = avctx->coded_width;
816
7
            s->v_edge_pos = avctx->coded_height;
817
        }
818
    }
819
820
    // do parse frame header
821
476
    v->pic_header_flag = 0;
822
476
    v->first_pic_header_flag = 1;
823
476
    if (v->profile < PROFILE_ADVANCED) {
824
178
        if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
825
            goto err;
826
        }
827
    } else {
828
298
        if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
829
            goto err;
830
        }
831
    }
832
476
    v->first_pic_header_flag = 0;
833
834
476
    if (avctx->debug & FF_DEBUG_PICT_INFO)
835
        av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
836
837

476
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
838
        && s->pict_type != AV_PICTURE_TYPE_I) {
839
        av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
840
        ret = AVERROR_INVALIDDATA;
841
        goto err;
842
    }
843

476
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
844
        && v->field_mode) {
845
        av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
846
        ret = AVERROR_INVALIDDATA;
847
        goto err;
848
    }
849
476
    if ((s->mb_height >> v->field_mode) == 0) {
850
        av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
851
        ret = AVERROR_INVALIDDATA;
852
        goto err;
853
    }
854
855
    // for skipping the frame
856
476
    s->current_picture.f->pict_type = s->pict_type;
857
476
    s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
858
859
    /* skip B-frames if we don't have reference frames */
860

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

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

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

1109
            if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
1041
36
                if (v->field_mode <= 0) {
1042
                    av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1043
                           "picture boundary (%d >= %d)\n", i,
1044
                           slices[i - 1].mby_start, mb_height);
1045
                    continue;
1046
                }
1047
36
                v->second_field = 1;
1048
36
                av_assert0((s->mb_height & 1) == 0);
1049
36
                v->blocks_off   = s->b8_stride * (s->mb_height&~1);
1050
36
                v->mb_off       = s->mb_stride * s->mb_height >> 1;
1051
            } else {
1052
1073
                v->second_field = 0;
1053
1073
                v->blocks_off   = 0;
1054
1073
                v->mb_off       = 0;
1055
            }
1056
1109
            if (i) {
1057
633
                v->pic_header_flag = 0;
1058

633
                if (v->field_mode && i == n_slices1 + 2) {
1059
36
                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1060
                        av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1061
                        ret = AVERROR_INVALIDDATA;
1062
                        if (avctx->err_recognition & AV_EF_EXPLODE)
1063
                            goto err;
1064
                        continue;
1065
                    }
1066
597
                } else if (get_bits1(&s->gb)) {
1067
271
                    v->pic_header_flag = 1;
1068
271
                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1069
                        av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1070
                        ret = AVERROR_INVALIDDATA;
1071
                        if (avctx->err_recognition & AV_EF_EXPLODE)
1072
                            goto err;
1073
                        continue;
1074
                    }
1075
                }
1076
            }
1077
1109
            if (header_ret < 0)
1078
                continue;
1079
1109
            s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1080

1109
            if (!v->field_mode || v->second_field)
1081
1073
                s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1082
            else {
1083
36
                if (i >= n_slices) {
1084
                    av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1085
                    continue;
1086
                }
1087
36
                s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1088
            }
1089
1109
            if (s->end_mb_y <= s->start_mb_y) {
1090
                av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1091
                continue;
1092
            }
1093

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

194
                 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1095
1024
                !v->cbpcy_vlc) {
1096
                av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1097
                continue;
1098
            }
1099
1109
            ff_vc1_decode_blocks(v);
1100
1109
            if (i != n_slices) {
1101
633
                s->gb = slices[i].gb;
1102
            }
1103
        }
1104
476
        if (v->field_mode) {
1105
36
            v->second_field = 0;
1106
36
            s->current_picture.f->linesize[0] >>= 1;
1107
36
            s->current_picture.f->linesize[1] >>= 1;
1108
36
            s->current_picture.f->linesize[2] >>= 1;
1109
36
            s->linesize                      >>= 1;
1110
36
            s->uvlinesize                    >>= 1;
1111

36
            if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1112
18
                FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1113
18
                FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1114
            }
1115
        }
1116
        ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1117
                get_bits_count(&s->gb), s->gb.size_in_bits);
1118
//  if (get_bits_count(&s->gb) > buf_size * 8)
1119
//      return -1;
1120

476
        if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1121
            ret = AVERROR_INVALIDDATA;
1122
            goto err;
1123
        }
1124
476
        if (!v->field_mode)
1125
440
            ff_er_frame_end(&s->er);
1126
    }
1127
1128
476
    ff_mpv_frame_end(s);
1129
1130

476
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1131
image:
1132
        avctx->width  = avctx->coded_width  = v->output_width;
1133
        avctx->height = avctx->coded_height = v->output_height;
1134
        if (avctx->skip_frame >= AVDISCARD_NONREF)
1135
            goto end;
1136
        if (!v->sprite_output_frame &&
1137
            !(v->sprite_output_frame = av_frame_alloc())) {
1138
            ret = AVERROR(ENOMEM);
1139
            goto err;
1140
        }
1141
#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1142
        if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1143
            goto err;
1144
#endif
1145
        if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1146
            goto err;
1147
        *got_frame = 1;
1148
    } else {
1149

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