mpeg4videodec.c 107 KB
Newer Older
1
/*
2
 * MPEG-4 decoder
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * Copyright (c) 2000,2001 Fabrice Bellard
 * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

23 24
#define UNCHECKED_BITSTREAM_READER 1

25
#include "libavutil/internal.h"
26
#include "libavutil/opt.h"
27
#include "error_resilience.h"
28
#include "idctdsp.h"
29
#include "internal.h"
30
#include "mpegutils.h"
31
#include "mpegvideo.h"
32
#include "mpegvideodata.h"
33 34
#include "mpeg4video.h"
#include "h263.h"
35
#include "profiles.h"
36
#include "thread.h"
37
#include "xvididct.h"
38

39 40 41 42
/* The defines below define the number of bits that are read at once for
 * reading vlc values. Changing these may improve speed and data cache needs
 * be aware though that decreasing them may need the number of stages that is
 * passed to get_vlc* to be increased. */
43 44 45 46 47 48 49 50
#define SPRITE_TRAJ_VLC_BITS 6
#define DC_VLC_BITS 9
#define MB_TYPE_B_VLC_BITS 4

static VLC dc_lum, dc_chrom;
static VLC sprite_trajectory;
static VLC mb_type_b_vlc;

51
static const int mb_type_b_map[4] = {
52
    MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
53 54 55
    MB_TYPE_L0L1    | MB_TYPE_16x16,
    MB_TYPE_L1      | MB_TYPE_16x16,
    MB_TYPE_L0      | MB_TYPE_16x16,
56 57 58
};

/**
59
 * Predict the ac.
60 61 62
 * @param n block index (0-3 are luma, 4-5 are chroma)
 * @param dir the ac prediction direction
 */
63
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
64 65 66
{
    int i;
    int16_t *ac_val, *ac_val1;
67
    int8_t *const qscale_table = s->current_picture.qscale_table;
68 69

    /* find prediction */
70
    ac_val  = &s->ac_val[0][0][0] + s->block_index[n] * 16;
71 72 73
    ac_val1 = ac_val;
    if (s->ac_pred) {
        if (dir == 0) {
74
            const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride;
75 76 77
            /* left prediction */
            ac_val -= 16;

78 79
            if (s->mb_x == 0 || s->qscale == qscale_table[xy] ||
                n == 1 || n == 3) {
80
                /* same qscale */
81
                for (i = 1; i < 8; i++)
82
                    block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
83
            } else {
84
                /* different qscale, we must rescale */
85
                for (i = 1; i < 8; i++)
86
                    block[s->idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
87 88
            }
        } else {
89
            const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
90 91 92
            /* top prediction */
            ac_val -= 16 * s->block_wrap[n];

93 94
            if (s->mb_y == 0 || s->qscale == qscale_table[xy] ||
                n == 2 || n == 3) {
95
                /* same qscale */
96
                for (i = 1; i < 8; i++)
97
                    block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
98
            } else {
99
                /* different qscale, we must rescale */
100
                for (i = 1; i < 8; i++)
101
                    block[s->idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
102 103 104 105
            }
        }
    }
    /* left copy */
106
    for (i = 1; i < 8; i++)
107
        ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
108 109

    /* top copy */
110
    for (i = 1; i < 8; i++)
111
        ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
112 113 114 115 116 117
}

/**
 * check if the next stuff is a resync marker or the end.
 * @return 0 if not
 */
118
static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
119
{
120
    MpegEncContext *s = &ctx->m;
121 122
    int bits_count = get_bits_count(&s->gb);
    int v          = show_bits(&s->gb, 16);
123

124
    if (s->workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker)
125 126
        return 0;

127 128 129
    while (v <= 0xFF) {
        if (s->pict_type == AV_PICTURE_TYPE_B ||
            (v >> (8 - s->pict_type) != 1) || s->partitioned_frame)
130
            break;
131 132 133
        skip_bits(&s->gb, 8 + s->pict_type);
        bits_count += 8 + s->pict_type;
        v = show_bits(&s->gb, 16);
134 135
    }

136 137 138
    if (bits_count + 8 >= s->gb.size_in_bits) {
        v >>= 8;
        v  |= 0x7F >> (7 - (bits_count & 7));
139

140
        if (v == 0x7F)
141
            return s->mb_num;
142 143
    } else {
        if (v == ff_mpeg4_resync_prefix[bits_count & 7]) {
144
            int len, mb_num;
145
            int mb_num_bits = av_log2(s->mb_num - 1) + 1;
146
            GetBitContext gb = s->gb;
147 148 149 150

            skip_bits(&s->gb, 1);
            align_get_bits(&s->gb);

151 152 153
            for (len = 0; len < 32; len++)
                if (get_bits1(&s->gb))
                    break;
154

155 156
            mb_num = get_bits(&s->gb, mb_num_bits);
            if (!mb_num || mb_num > s->mb_num || get_bits_count(&s->gb)+6 > s->gb.size_in_bits)
157 158
                mb_num= -1;

159
            s->gb = gb;
160

161
            if (len >= ff_mpeg4_get_video_packet_prefix_length(s))
162
                return mb_num;
163 164 165 166 167
        }
    }
    return 0;
}

168
static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
169
{
170
    MpegEncContext *s = &ctx->m;
171 172 173 174 175 176 177 178
    int a     = 2 << s->sprite_warping_accuracy;
    int rho   = 3  - s->sprite_warping_accuracy;
    int r     = 16 / a;
    int alpha = 0;
    int beta  = 0;
    int w     = s->width;
    int h     = s->height;
    int min_ab, i, w2, h2, w3, h3;
179 180
    int sprite_ref[4][2];
    int virtual_ref[2][2];
181 182 183 184 185

    // only true for rectangle shapes
    const int vop_ref[4][2] = { { 0, 0 },         { s->width, 0 },
                                { 0, s->height }, { s->width, s->height } };
    int d[4][2]             = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
186

187 188
    if (w <= 0 || h <= 0)
        return AVERROR_INVALIDDATA;
189

190
    for (i = 0; i < ctx->num_sprite_warping_points; i++) {
191
        int length;
192
        int x = 0, y = 0;
193

194
        length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
195
        if (length > 0)
196
            x = get_xbits(gb, length);
197

198
        if (!(ctx->divx_version == 500 && ctx->divx_build == 413))
199
            check_marker(s->avctx, gb, "before sprite_trajectory");
200 201

        length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
202
        if (length > 0)
203 204
            y = get_xbits(gb, length);

205
        check_marker(s->avctx, gb, "after sprite_trajectory");
206 207
        ctx->sprite_traj[i][0] = d[i][0] = x;
        ctx->sprite_traj[i][1] = d[i][1] = y;
208
    }
209
    for (; i < 4; i++)
210
        ctx->sprite_traj[i][0] = ctx->sprite_traj[i][1] = 0;
211 212 213 214

    while ((1 << alpha) < w)
        alpha++;
    while ((1 << beta) < h)
215
        beta++;  /* typo in the MPEG-4 std for the definition of w' and h' */
216 217 218 219
    w2 = 1 << alpha;
    h2 = 1 << beta;

    // Note, the 4th point isn't used for GMC
220
    if (ctx->divx_version == 500 && ctx->divx_build == 413) {
221 222 223 224 225 226
        sprite_ref[0][0] = a * vop_ref[0][0] + d[0][0];
        sprite_ref[0][1] = a * vop_ref[0][1] + d[0][1];
        sprite_ref[1][0] = a * vop_ref[1][0] + d[0][0] + d[1][0];
        sprite_ref[1][1] = a * vop_ref[1][1] + d[0][1] + d[1][1];
        sprite_ref[2][0] = a * vop_ref[2][0] + d[0][0] + d[2][0];
        sprite_ref[2][1] = a * vop_ref[2][1] + d[0][1] + d[2][1];
227
    } else {
228 229 230 231 232 233
        sprite_ref[0][0] = (a >> 1) * (2 * vop_ref[0][0] + d[0][0]);
        sprite_ref[0][1] = (a >> 1) * (2 * vop_ref[0][1] + d[0][1]);
        sprite_ref[1][0] = (a >> 1) * (2 * vop_ref[1][0] + d[0][0] + d[1][0]);
        sprite_ref[1][1] = (a >> 1) * (2 * vop_ref[1][1] + d[0][1] + d[1][1]);
        sprite_ref[2][0] = (a >> 1) * (2 * vop_ref[2][0] + d[0][0] + d[2][0]);
        sprite_ref[2][1] = (a >> 1) * (2 * vop_ref[2][1] + d[0][1] + d[2][1]);
234
    }
235 236 237
    /* sprite_ref[3][0] = (a >> 1) * (2 * vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
     * sprite_ref[3][1] = (a >> 1) * (2 * vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */

238
    /* This is mostly identical to the MPEG-4 std (and is totally unreadable
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
     * because of that...). Perhaps it should be reordered to be more readable.
     * The idea behind this virtual_ref mess is to be able to use shifts later
     * per pixel instead of divides so the distance between points is converted
     * from w&h based to w2&h2 based which are of the 2^x form. */
    virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +
                         ROUNDED_DIV(((w - w2) *
                                      (r * sprite_ref[0][0] - 16 * vop_ref[0][0]) +
                                      w2 * (r * sprite_ref[1][0] - 16 * vop_ref[1][0])), w);
    virtual_ref[0][1] = 16 * vop_ref[0][1] +
                        ROUNDED_DIV(((w - w2) *
                                     (r * sprite_ref[0][1] - 16 * vop_ref[0][1]) +
                                     w2 * (r * sprite_ref[1][1] - 16 * vop_ref[1][1])), w);
    virtual_ref[1][0] = 16 * vop_ref[0][0] +
                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16 * vop_ref[0][0]) +
                                     h2 * (r * sprite_ref[2][0] - 16 * vop_ref[2][0])), h);
    virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +
                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16 * vop_ref[0][1]) +
                                     h2 * (r * sprite_ref[2][1] - 16 * vop_ref[2][1])), h);

258
    switch (ctx->num_sprite_warping_points) {
259 260 261 262 263 264 265 266 267
    case 0:
        s->sprite_offset[0][0] =
        s->sprite_offset[0][1] =
        s->sprite_offset[1][0] =
        s->sprite_offset[1][1] = 0;
        s->sprite_delta[0][0]  = a;
        s->sprite_delta[0][1]  =
        s->sprite_delta[1][0]  = 0;
        s->sprite_delta[1][1]  = a;
268 269
        ctx->sprite_shift[0]   =
        ctx->sprite_shift[1]   = 0;
270 271 272 273 274 275 276 277 278 279 280 281
        break;
    case 1:     // GMC only
        s->sprite_offset[0][0] = sprite_ref[0][0] - a * vop_ref[0][0];
        s->sprite_offset[0][1] = sprite_ref[0][1] - a * vop_ref[0][1];
        s->sprite_offset[1][0] = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
                                 a * (vop_ref[0][0] / 2);
        s->sprite_offset[1][1] = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
                                 a * (vop_ref[0][1] / 2);
        s->sprite_delta[0][0]  = a;
        s->sprite_delta[0][1]  =
        s->sprite_delta[1][0]  = 0;
        s->sprite_delta[1][1]  = a;
282 283
        ctx->sprite_shift[0]   =
        ctx->sprite_shift[1]   = 0;
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
        break;
    case 2:
        s->sprite_offset[0][0] = (sprite_ref[0][0] << (alpha + rho)) +
                                 (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
                                 (-vop_ref[0][0]) +
                                 (r * sprite_ref[0][1] - virtual_ref[0][1]) *
                                 (-vop_ref[0][1]) + (1 << (alpha + rho - 1));
        s->sprite_offset[0][1] = (sprite_ref[0][1] << (alpha + rho)) +
                                 (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
                                 (-vop_ref[0][0]) +
                                 (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
                                 (-vop_ref[0][1]) + (1 << (alpha + rho - 1));
        s->sprite_offset[1][0] = ((-r * sprite_ref[0][0] + virtual_ref[0][0]) *
                                  (-2 * vop_ref[0][0] + 1) +
                                  (r * sprite_ref[0][1] - virtual_ref[0][1]) *
                                  (-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
                                  sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));
        s->sprite_offset[1][1] = ((-r * sprite_ref[0][1] + virtual_ref[0][1]) *
                                  (-2 * vop_ref[0][0] + 1) +
                                  (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
                                  (-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
                                  sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));
        s->sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
        s->sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);
        s->sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);
        s->sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);

311 312
        ctx->sprite_shift[0]  = alpha + rho;
        ctx->sprite_shift[1]  = alpha + rho + 2;
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
        break;
    case 3:
        min_ab = FFMIN(alpha, beta);
        w3     = w2 >> min_ab;
        h3     = h2 >> min_ab;
        s->sprite_offset[0][0] = (sprite_ref[0][0] << (alpha + beta + rho - min_ab)) +
                                 (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
                                 h3 * (-vop_ref[0][0]) +
                                 (-r * sprite_ref[0][0] + virtual_ref[1][0]) *
                                 w3 * (-vop_ref[0][1]) +
                                 (1 << (alpha + beta + rho - min_ab - 1));
        s->sprite_offset[0][1] = (sprite_ref[0][1] << (alpha + beta + rho - min_ab)) +
                                 (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
                                 h3 * (-vop_ref[0][0]) +
                                 (-r * sprite_ref[0][1] + virtual_ref[1][1]) *
                                 w3 * (-vop_ref[0][1]) +
                                 (1 << (alpha + beta + rho - min_ab - 1));
        s->sprite_offset[1][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
                                 h3 * (-2 * vop_ref[0][0] + 1) +
                                 (-r * sprite_ref[0][0] + virtual_ref[1][0]) *
                                 w3 * (-2 * vop_ref[0][1] + 1) + 2 * w2 * h3 *
                                 r * sprite_ref[0][0] - 16 * w2 * h3 +
                                 (1 << (alpha + beta + rho - min_ab + 1));
        s->sprite_offset[1][1] = (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
                                 h3 * (-2 * vop_ref[0][0] + 1) +
                                 (-r * sprite_ref[0][1] + virtual_ref[1][1]) *
                                 w3 * (-2 * vop_ref[0][1] + 1) + 2 * w2 * h3 *
                                 r * sprite_ref[0][1] - 16 * w2 * h3 +
                                 (1 << (alpha + beta + rho - min_ab + 1));
        s->sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3;
        s->sprite_delta[0][1] = (-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3;
        s->sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3;
        s->sprite_delta[1][1] = (-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3;

347 348
        ctx->sprite_shift[0]  = alpha + beta + rho - min_ab;
        ctx->sprite_shift[1]  = alpha + beta + rho - min_ab + 2;
349
        break;
350 351
    }
    /* try to simplify the situation */
352
    if (s->sprite_delta[0][0] == a << ctx->sprite_shift[0] &&
353 354
        s->sprite_delta[0][1] == 0 &&
        s->sprite_delta[1][0] == 0 &&
355 356 357 358 359
        s->sprite_delta[1][1] == a << ctx->sprite_shift[0]) {
        s->sprite_offset[0][0] >>= ctx->sprite_shift[0];
        s->sprite_offset[0][1] >>= ctx->sprite_shift[0];
        s->sprite_offset[1][0] >>= ctx->sprite_shift[1];
        s->sprite_offset[1][1] >>= ctx->sprite_shift[1];
360 361 362 363
        s->sprite_delta[0][0] = a;
        s->sprite_delta[0][1] = 0;
        s->sprite_delta[1][0] = 0;
        s->sprite_delta[1][1] = a;
364 365
        ctx->sprite_shift[0] = 0;
        ctx->sprite_shift[1] = 0;
366 367
        s->real_sprite_warping_points = 1;
    } else {
368 369
        int shift_y = 16 - ctx->sprite_shift[0];
        int shift_c = 16 - ctx->sprite_shift[1];
370 371 372 373 374
        for (i = 0; i < 2; i++) {
            s->sprite_offset[0][i] <<= shift_y;
            s->sprite_offset[1][i] <<= shift_c;
            s->sprite_delta[0][i]  <<= shift_y;
            s->sprite_delta[1][i]  <<= shift_y;
375
            ctx->sprite_shift[i]     = 16;
376
        }
377
        s->real_sprite_warping_points = ctx->num_sprite_warping_points;
378
    }
379

380
    return 0;
381 382
}

383
static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
384
    MpegEncContext *s = &ctx->m;
385
    int len = FFMIN(ctx->time_increment_bits + 3, 15);
386 387 388 389

    get_bits(gb, len);
    if (get_bits1(gb))
        get_bits(gb, len);
390
    check_marker(s->avctx, gb, "after new_pred");
391 392 393 394

    return 0;
}

395
/**
396
 * Decode the next video packet.
397 398
 * @return <0 if something went wrong
 */
399
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
400
{
401 402
    MpegEncContext *s = &ctx->m;

403 404
    int mb_num_bits      = av_log2(s->mb_num - 1) + 1;
    int header_extension = 0, mb_num, len;
405 406

    /* is there enough space left for a video packet + header */
407 408
    if (get_bits_count(&s->gb) > s->gb.size_in_bits - 20)
        return -1;
409

410 411 412
    for (len = 0; len < 32; len++)
        if (get_bits1(&s->gb))
            break;
413

414
    if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
415 416 417 418
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
        return -1;
    }

419
    if (ctx->shape != RECT_SHAPE) {
420 421
        header_extension = get_bits1(&s->gb);
        // FIXME more stuff here
422 423
    }

424 425 426 427
    mb_num = get_bits(&s->gb, mb_num_bits);
    if (mb_num >= s->mb_num) {
        av_log(s->avctx, AV_LOG_ERROR,
               "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
428 429 430
        return -1;
    }

431 432
    s->mb_x = mb_num % s->mb_width;
    s->mb_y = mb_num / s->mb_width;
433

434
    if (ctx->shape != BIN_ONLY_SHAPE) {
435 436 437
        int qscale = get_bits(&s->gb, s->quant_precision);
        if (qscale)
            s->chroma_qscale = s->qscale = qscale;
438 439
    }

440
    if (ctx->shape == RECT_SHAPE)
441 442 443 444
        header_extension = get_bits1(&s->gb);

    if (header_extension) {
        int time_incr = 0;
445 446 447 448

        while (get_bits1(&s->gb) != 0)
            time_incr++;

449
        check_marker(s->avctx, &s->gb, "before time_increment in video packed header");
450
        skip_bits(&s->gb, ctx->time_increment_bits);      /* time_increment */
451
        check_marker(s->avctx, &s->gb, "before vop_coding_type in video packed header");
452 453

        skip_bits(&s->gb, 2); /* vop coding type */
454
        // FIXME not rect stuff here
455

456
        if (ctx->shape != BIN_ONLY_SHAPE) {
457
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
458 459
            // FIXME don't just ignore everything
            if (s->pict_type == AV_PICTURE_TYPE_S &&
460
                ctx->vol_sprite_usage == GMC_SPRITE) {
461
                if (mpeg4_decode_sprite_trajectory(ctx, &s->gb) < 0)
462
                    return AVERROR_INVALIDDATA;
463 464 465
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
            }

466
            // FIXME reduced res stuff here
467

468
            if (s->pict_type != AV_PICTURE_TYPE_I) {
469
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
470 471 472
                if (f_code == 0)
                    av_log(s->avctx, AV_LOG_ERROR,
                           "Error, video packet header damaged (f_code=0)\n");
473
            }
474
            if (s->pict_type == AV_PICTURE_TYPE_B) {
475
                int b_code = get_bits(&s->gb, 3);
476 477 478
                if (b_code == 0)
                    av_log(s->avctx, AV_LOG_ERROR,
                           "Error, video packet header damaged (b_code=0)\n");
479 480 481
            }
        }
    }
482
    if (ctx->new_pred)
483
        decode_new_pred(ctx, &s->gb);
484 485 486 487 488

    return 0;
}

/**
489
 * Get the average motion vector for a GMC MB.
490
 * @param n either 0 for the x component or 1 for y
491
 * @return the average MV for a GMC MB
492
 */
493
static inline int get_amv(Mpeg4DecContext *ctx, int n)
494
{
495
    MpegEncContext *s = &ctx->m;
496
    int x, y, mb_v, sum, dx, dy, shift;
497 498
    int len     = 1 << (s->f_code + 4);
    const int a = s->sprite_warping_accuracy;
499

500
    if (s->workaround_bugs & FF_BUG_AMV)
501 502
        len >>= s->quarter_sample;

503
    if (s->real_sprite_warping_points == 1) {
504
        if (ctx->divx_version == 500 && ctx->divx_build == 413)
505 506 507 508 509 510
            sum = s->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
        else
            sum = RSHIFT(s->sprite_offset[0][n] << s->quarter_sample, a);
    } else {
        dx    = s->sprite_delta[n][0];
        dy    = s->sprite_delta[n][1];
511
        shift = ctx->sprite_shift[0];
512 513
        if (n)
            dy -= 1 << (shift + a + 1);
514
        else
515 516 517 518 519
            dx -= 1 << (shift + a + 1);
        mb_v = s->sprite_offset[0][n] + dx * s->mb_x * 16 + dy * s->mb_y * 16;

        sum = 0;
        for (y = 0; y < 16; y++) {
520 521
            int v;

522 523 524 525 526
            v = mb_v + dy * y;
            // FIXME optimize
            for (x = 0; x < 16; x++) {
                sum += v >> shift;
                v   += dx;
527 528
            }
        }
529
        sum = RSHIFT(sum, a + 8 - s->quarter_sample);
530 531
    }

532 533 534 535
    if (sum < -len)
        sum = -len;
    else if (sum >= len)
        sum = len - 1;
536 537 538 539 540

    return sum;
}

/**
541
 * Decode the dc value.
542 543 544 545
 * @param n block index (0-3 are luma, 4-5 are chroma)
 * @param dir_ptr the prediction direction will be stored here
 * @return the quantized dc
 */
546
static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
547 548 549 550 551 552 553
{
    int level, code;

    if (n < 4)
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
    else
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
554 555

    if (code < 0 || code > 9 /* && s->nbit < 9 */) {
556 557 558
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
        return -1;
    }
559

560 561 562
    if (code == 0) {
        level = 0;
    } else {
563 564 565 566 567 568
        if (IS_3IV1) {
            if (code == 1)
                level = 2 * get_bits1(&s->gb) - 1;
            else {
                if (get_bits1(&s->gb))
                    level = get_bits(&s->gb, code - 1) + (1 << (code - 1));
569
                else
570
                    level = -get_bits(&s->gb, code - 1) - (1 << (code - 1));
571
            }
572
        } else {
573 574 575
            level = get_xbits(&s->gb, code);
        }

576 577
        if (code > 8) {
            if (get_bits1(&s->gb) == 0) { /* marker */
578
                if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
579 580 581 582 583 584 585 586 587 588 589
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
                    return -1;
                }
            }
        }
    }

    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
}

/**
590
 * Decode first partition.
591 592
 * @return number of MBs decoded or <0 if an error occurred
 */
593
static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
594
{
595
    MpegEncContext *s = &ctx->m;
596
    int mb_num = 0;
597 598 599
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };

    /* decode first partition */
600 601
    s->first_slice_line = 1;
    for (; s->mb_y < s->mb_height; s->mb_y++) {
602
        ff_init_block_index(s);
603 604
        for (; s->mb_x < s->mb_width; s->mb_x++) {
            const int xy = s->mb_x + s->mb_y * s->mb_stride;
605
            int cbpc;
606
            int dir = 0;
607 608 609

            mb_num++;
            ff_update_block_index(s);
610 611
            if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
                s->first_slice_line = 0;
612

613
            if (s->pict_type == AV_PICTURE_TYPE_I) {
614 615
                int i;

616 617 618
                do {
                    if (show_bits_long(&s->gb, 19) == DC_MARKER)
                        return mb_num - 1;
619

620
                    cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
621 622
                    if (cbpc < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
623
                               "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
624 625
                        return -1;
                    }
626
                } while (cbpc == 8);
627

628
                s->cbp_table[xy]               = cbpc & 3;
629
                s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
630
                s->mb_intra                    = 1;
631

632
                if (cbpc & 4)
633 634
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);

635 636 637 638
                s->current_picture.qscale_table[xy] = s->qscale;

                s->mbintra_table[xy] = 1;
                for (i = 0; i < 6; i++) {
639
                    int dc_pred_dir;
640 641 642 643
                    int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
                    if (dc < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
644 645
                        return -1;
                    }
646 647 648
                    dir <<= 1;
                    if (dc_pred_dir)
                        dir |= 1;
649
                }
650 651
                s->pred_dir_table[xy] = dir;
            } else { /* P/S_TYPE */
652
                int mx, my, pred_x, pred_y, bits;
653 654
                int16_t *const mot_val = s->current_picture.motion_val[0][s->block_index[0]];
                const int stride       = s->b8_stride * 2;
655 656

try_again:
657 658 659 660
                bits = show_bits(&s->gb, 17);
                if (bits == MOTION_MARKER)
                    return mb_num - 1;

661
                skip_bits1(&s->gb);
662
                if (bits & 0x10000) {
663
                    /* skip mb */
664
                    if (s->pict_type == AV_PICTURE_TYPE_S &&
665
                        ctx->vol_sprite_usage == GMC_SPRITE) {
666 667 668 669
                        s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                         MB_TYPE_16x16 |
                                                         MB_TYPE_GMC   |
                                                         MB_TYPE_L0;
670 671
                        mx = get_amv(ctx, 0);
                        my = get_amv(ctx, 1);
672 673 674 675 676
                    } else {
                        s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                         MB_TYPE_16x16 |
                                                         MB_TYPE_L0;
                        mx = my = 0;
677
                    }
678 679 680 681 682 683 684 685 686 687
                    mot_val[0]          =
                    mot_val[2]          =
                    mot_val[0 + stride] =
                    mot_val[2 + stride] = mx;
                    mot_val[1]          =
                    mot_val[3]          =
                    mot_val[1 + stride] =
                    mot_val[3 + stride] = my;

                    if (s->mbintra_table[xy])
688 689 690 691
                        ff_clean_intra_table_entries(s);
                    continue;
                }

692
                cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
693 694
                if (cbpc < 0) {
                    av_log(s->avctx, AV_LOG_ERROR,
695
                           "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
696 697
                    return -1;
                }
698
                if (cbpc == 20)
699 700
                    goto try_again;

701
                s->cbp_table[xy] = cbpc & (8 + 3);  // 8 is dquant
702 703 704

                s->mb_intra = ((cbpc & 4) != 0);

705
                if (s->mb_intra) {
706
                    s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
707 708 709 710 711 712 713 714 715 716 717
                    s->mbintra_table[xy] = 1;
                    mot_val[0]          =
                    mot_val[2]          =
                    mot_val[0 + stride] =
                    mot_val[2 + stride] = 0;
                    mot_val[1]          =
                    mot_val[3]          =
                    mot_val[1 + stride] =
                    mot_val[3 + stride] = 0;
                } else {
                    if (s->mbintra_table[xy])
718 719
                        ff_clean_intra_table_entries(s);

720
                    if (s->pict_type == AV_PICTURE_TYPE_S &&
721
                        ctx->vol_sprite_usage == GMC_SPRITE &&
722 723 724 725
                        (cbpc & 16) == 0)
                        s->mcsel = get_bits1(&s->gb);
                    else
                        s->mcsel = 0;
726 727 728 729

                    if ((cbpc & 16) == 0) {
                        /* 16x16 motion prediction */

730
                        ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
731
                        if (!s->mcsel) {
732
                            mx = ff_h263_decode_motion(s, pred_x, s->f_code);
733 734 735
                            if (mx >= 0xffff)
                                return -1;

736
                            my = ff_h263_decode_motion(s, pred_y, s->f_code);
737 738
                            if (my >= 0xffff)
                                return -1;
739 740
                            s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
                                                             MB_TYPE_L0;
741
                        } else {
742 743
                            mx = get_amv(ctx, 0);
                            my = get_amv(ctx, 1);
744 745 746
                            s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
                                                             MB_TYPE_GMC   |
                                                             MB_TYPE_L0;
747 748
                        }

749 750 751 752 753 754 755 756
                        mot_val[0]          =
                        mot_val[2]          =
                        mot_val[0 + stride] =
                        mot_val[2 + stride] = mx;
                        mot_val[1]          =
                        mot_val[3]          =
                        mot_val[1 + stride] =
                        mot_val[3 + stride] = my;
757 758
                    } else {
                        int i;
759 760 761 762
                        s->current_picture.mb_type[xy] = MB_TYPE_8x8 |
                                                         MB_TYPE_L0;
                        for (i = 0; i < 4; i++) {
                            int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
763
                            mx = ff_h263_decode_motion(s, pred_x, s->f_code);
764 765 766
                            if (mx >= 0xffff)
                                return -1;

767
                            my = ff_h263_decode_motion(s, pred_y, s->f_code);
768 769 770 771 772 773 774 775 776
                            if (my >= 0xffff)
                                return -1;
                            mot_val[0] = mx;
                            mot_val[1] = my;
                        }
                    }
                }
            }
        }
777
        s->mb_x = 0;
778 779 780 781 782 783 784 785 786
    }

    return mb_num;
}

/**
 * decode second partition.
 * @return <0 if an error occurred
 */
787 788 789
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
{
    int mb_num = 0;
790 791
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };

792 793 794
    s->mb_x = s->resync_mb_x;
    s->first_slice_line = 1;
    for (s->mb_y = s->resync_mb_y; mb_num < mb_count; s->mb_y++) {
795
        ff_init_block_index(s);
796 797
        for (; mb_num < mb_count && s->mb_x < s->mb_width; s->mb_x++) {
            const int xy = s->mb_x + s->mb_y * s->mb_stride;
798 799 800

            mb_num++;
            ff_update_block_index(s);
801 802 803 804 805 806 807 808 809
            if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
                s->first_slice_line = 0;

            if (s->pict_type == AV_PICTURE_TYPE_I) {
                int ac_pred = get_bits1(&s->gb);
                int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
                if (cbpy < 0) {
                    av_log(s->avctx, AV_LOG_ERROR,
                           "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
810 811 812
                    return -1;
                }

813 814 815
                s->cbp_table[xy]               |= cbpy << 2;
                s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
            } else { /* P || S_TYPE */
816
                if (IS_INTRA(s->current_picture.mb_type[xy])) {
817 818
                    int i;
                    int dir     = 0;
819
                    int ac_pred = get_bits1(&s->gb);
820
                    int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
821

822 823 824
                    if (cbpy < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
825 826 827
                        return -1;
                    }

828
                    if (s->cbp_table[xy] & 8)
829
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
830
                    s->current_picture.qscale_table[xy] = s->qscale;
831

832
                    for (i = 0; i < 6; i++) {
833
                        int dc_pred_dir;
834 835 836 837
                        int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
                        if (dc < 0) {
                            av_log(s->avctx, AV_LOG_ERROR,
                                   "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
838 839
                            return -1;
                        }
840 841 842
                        dir <<= 1;
                        if (dc_pred_dir)
                            dir |= 1;
843
                    }
844 845 846 847
                    s->cbp_table[xy]               &= 3;  // remove dquant
                    s->cbp_table[xy]               |= cbpy << 2;
                    s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
                    s->pred_dir_table[xy]           = dir;
848 849
                } else if (IS_SKIP(s->current_picture.mb_type[xy])) {
                    s->current_picture.qscale_table[xy] = s->qscale;
850 851
                    s->cbp_table[xy]                    = 0;
                } else {
852
                    int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
853

854 855 856
                    if (cbpy < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
857 858 859
                        return -1;
                    }

860
                    if (s->cbp_table[xy] & 8)
861
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
862
                    s->current_picture.qscale_table[xy] = s->qscale;
863

864 865
                    s->cbp_table[xy] &= 3;  // remove dquant
                    s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
866 867 868
                }
            }
        }
869 870 871
        if (mb_num >= mb_count)
            return 0;
        s->mb_x = 0;
872 873 874 875 876
    }
    return 0;
}

/**
877
 * Decode the first and second partition.
878 879
 * @return <0 if error (and sets error type in the error_status_table)
 */
880
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
881
{
882
    MpegEncContext *s = &ctx->m;
883
    int mb_num;
884 885
    const int part_a_error = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR;
    const int part_a_end   = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_END   | ER_MV_END)   : ER_MV_END;
886

887
    mb_num = mpeg4_decode_partition_a(ctx);
888
    if (mb_num <= 0) {
889 890
        ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                        s->mb_x, s->mb_y, part_a_error);
891 892 893
        return -1;
    }

894
    if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) {
895
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
896 897
        ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                        s->mb_x, s->mb_y, part_a_error);
898 899 900
        return -1;
    }

901
    s->mb_num_left = mb_num;
902

903 904
    if (s->pict_type == AV_PICTURE_TYPE_I) {
        while (show_bits(&s->gb, 9) == 1)
905
            skip_bits(&s->gb, 9);
906 907 908 909
        if (get_bits_long(&s->gb, 19) != DC_MARKER) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "marker missing after first I partition at %d %d\n",
                   s->mb_x, s->mb_y);
910 911
            return -1;
        }
912 913
    } else {
        while (show_bits(&s->gb, 10) == 1)
914
            skip_bits(&s->gb, 10);
915 916 917 918
        if (get_bits(&s->gb, 17) != MOTION_MARKER) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "marker missing after first P partition at %d %d\n",
                   s->mb_x, s->mb_y);
919 920 921
            return -1;
        }
    }
922 923
    ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                    s->mb_x - 1, s->mb_y, part_a_end);
924

925 926 927 928
    if (mpeg4_decode_partition_b(s, mb_num) < 0) {
        if (s->pict_type == AV_PICTURE_TYPE_P)
            ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                            s->mb_x, s->mb_y, ER_DC_ERROR);
929
        return -1;
930 931 932 933
    } else {
        if (s->pict_type == AV_PICTURE_TYPE_P)
            ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                            s->mb_x - 1, s->mb_y, ER_DC_END);
934 935 936 937 938 939
    }

    return 0;
}

/**
940
 * Decode a block.
941 942
 * @return <0 if an error occurred
 */
943
static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
944
                                     int n, int coded, int intra, int rvlc)
945
{
946
    MpegEncContext *s = &ctx->m;
947
    int level, i, last, run, qmul, qadd;
948
    int av_uninit(dc_pred_dir);
949 950 951 952 953 954 955
    RLTable *rl;
    RL_VLC_ELEM *rl_vlc;
    const uint8_t *scan_table;

    // Note intra & rvlc should be optimized away if this is inlined

    if (intra) {
956
        if (ctx->use_intra_dc_vlc) {
957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
            /* DC coef */
            if (s->partitioned_frame) {
                level = s->dc_val[0][s->block_index[n]];
                if (n < 4)
                    level = FASTDIV((level + (s->y_dc_scale >> 1)), s->y_dc_scale);
                else
                    level = FASTDIV((level + (s->c_dc_scale >> 1)), s->c_dc_scale);
                dc_pred_dir = (s->pred_dir_table[s->mb_x + s->mb_y * s->mb_stride] << n) & 32;
            } else {
                level = mpeg4_decode_dc(s, n, &dc_pred_dir);
                if (level < 0)
                    return -1;
            }
            block[0] = level;
            i        = 0;
        } else {
973 974
            i = -1;
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
        }
        if (!coded)
            goto not_coded;

        if (rvlc) {
            rl     = &ff_rvlc_rl_intra;
            rl_vlc = ff_rvlc_rl_intra.rl_vlc[0];
        } else {
            rl     = &ff_mpeg4_rl_intra;
            rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
        }
        if (s->ac_pred) {
            if (dc_pred_dir == 0)
                scan_table = s->intra_v_scantable.permutated;  /* left */
            else
                scan_table = s->intra_h_scantable.permutated;  /* top */
        } else {
992
            scan_table = s->intra_scantable.permutated;
993 994 995
        }
        qmul = 1;
        qadd = 0;
996 997 998 999 1000 1001
    } else {
        i = -1;
        if (!coded) {
            s->block_last_index[n] = i;
            return 0;
        }
1002 1003 1004 1005
        if (rvlc)
            rl = &ff_rvlc_rl_inter;
        else
            rl = &ff_h263_rl_inter;
1006 1007 1008

        scan_table = s->intra_scantable.permutated;

1009 1010 1011 1012
        if (s->mpeg_quant) {
            qmul = 1;
            qadd = 0;
            if (rvlc)
1013
                rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
1014
            else
1015
                rl_vlc = ff_h263_rl_inter.rl_vlc[0];
1016
        } else {
1017 1018
            qmul = s->qscale << 1;
            qadd = (s->qscale - 1) | 1;
1019
            if (rvlc)
1020
                rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
1021
            else
1022
                rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
1023 1024
        }
    }
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
    {
        OPEN_READER(re, &s->gb);
        for (;;) {
            UPDATE_CACHE(re, &s->gb);
            GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
            if (level == 0) {
                /* escape */
                if (rvlc) {
                    if (SHOW_UBITS(re, &s->gb, 1) == 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "1. marker bit missing in rvlc esc\n");
                        return -1;
                    }
                    SKIP_CACHE(re, &s->gb, 1);
1039

1040 1041 1042 1043
                    last = SHOW_UBITS(re, &s->gb, 1);
                    SKIP_CACHE(re, &s->gb, 1);
                    run = SHOW_UBITS(re, &s->gb, 6);
                    SKIP_COUNTER(re, &s->gb, 1 + 1 + 6);
1044 1045
                    UPDATE_CACHE(re, &s->gb);

1046 1047 1048 1049 1050 1051
                    if (SHOW_UBITS(re, &s->gb, 1) == 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "2. marker bit missing in rvlc esc\n");
                        return -1;
                    }
                    SKIP_CACHE(re, &s->gb, 1);
1052

1053 1054
                    level = SHOW_UBITS(re, &s->gb, 11);
                    SKIP_CACHE(re, &s->gb, 11);
1055

1056 1057 1058
                    if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
                        av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
                        return -1;
1059
                    }
1060
                    SKIP_CACHE(re, &s->gb, 5);
1061

1062 1063 1064
                    level = level * qmul + qadd;
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                    SKIP_COUNTER(re, &s->gb, 1 + 11 + 5 + 1);
1065

1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
                    i += run + 1;
                    if (last)
                        i += 192;
                } else {
                    int cache;
                    cache = GET_CACHE(re, &s->gb);

                    if (IS_3IV1)
                        cache ^= 0xC0000000;

                    if (cache & 0x80000000) {
                        if (cache & 0x40000000) {
                            /* third escape */
                            SKIP_CACHE(re, &s->gb, 2);
                            last = SHOW_UBITS(re, &s->gb, 1);
                            SKIP_CACHE(re, &s->gb, 1);
                            run = SHOW_UBITS(re, &s->gb, 6);
                            SKIP_COUNTER(re, &s->gb, 2 + 1 + 6);
                            UPDATE_CACHE(re, &s->gb);

                            if (IS_3IV1) {
                                level = SHOW_SBITS(re, &s->gb, 12);
                                LAST_SKIP_BITS(re, &s->gb, 12);
                            } else {
                                if (SHOW_UBITS(re, &s->gb, 1) == 0) {
                                    av_log(s->avctx, AV_LOG_ERROR,
                                           "1. marker bit missing in 3. esc\n");
1093
                                    if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
1094
                                        return -1;
1095 1096
                                }
                                SKIP_CACHE(re, &s->gb, 1);
1097

1098 1099
                                level = SHOW_SBITS(re, &s->gb, 12);
                                SKIP_CACHE(re, &s->gb, 12);
1100

1101 1102 1103
                                if (SHOW_UBITS(re, &s->gb, 1) == 0) {
                                    av_log(s->avctx, AV_LOG_ERROR,
                                           "2. marker bit missing in 3. esc\n");
1104
                                    if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
1105
                                        return -1;
1106
                                }
1107

1108
                                SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
1109 1110 1111
                            }

#if 0
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
                            if (s->error_recognition >= FF_ER_COMPLIANT) {
                                const int abs_level= FFABS(level);
                                if (abs_level<=MAX_LEVEL && run<=MAX_RUN) {
                                    const int run1= run - rl->max_run[last][abs_level] - 1;
                                    if (abs_level <= rl->max_level[last][run]) {
                                        av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
                                        return -1;
                                    }
                                    if (s->error_recognition > FF_ER_COMPLIANT) {
                                        if (abs_level <= rl->max_level[last][run]*2) {
                                            av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
                                            return -1;
                                        }
                                        if (run1 >= 0 && abs_level <= rl->max_level[last][run1]) {
                                            av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
                                            return -1;
                                        }
                                    }
1130 1131 1132
                                }
                            }
#endif
1133 1134 1135 1136 1137 1138
                            if (level > 0)
                                level = level * qmul + qadd;
                            else
                                level = level * qmul - qadd;

                            if ((unsigned)(level + 2048) > 4095) {
1139
                                if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) {
1140 1141 1142 1143 1144 1145 1146 1147
                                    if (level > 2560 || level < -2560) {
                                        av_log(s->avctx, AV_LOG_ERROR,
                                               "|level| overflow in 3. esc, qp=%d\n",
                                               s->qscale);
                                        return -1;
                                    }
                                }
                                level = level < 0 ? -2048 : 2047;
1148
                            }
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159

                            i += run + 1;
                            if (last)
                                i += 192;
                        } else {
                            /* second escape */
                            SKIP_BITS(re, &s->gb, 2);
                            GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
                            i    += run + rl->max_run[run >> 7][level / qmul] + 1;  // FIXME opt indexing
                            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                            LAST_SKIP_BITS(re, &s->gb, 1);
1160
                        }
1161 1162 1163 1164 1165 1166 1167 1168
                    } else {
                        /* first escape */
                        SKIP_BITS(re, &s->gb, 1);
                        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
                        i    += run;
                        level = level + rl->max_level[run >> 7][(run - 1) & 63] * qmul;  // FIXME opt indexing
                        level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                        LAST_SKIP_BITS(re, &s->gb, 1);
1169 1170 1171
                    }
                }
            } else {
1172
                i    += run;
1173 1174 1175
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                LAST_SKIP_BITS(re, &s->gb, 1);
            }
1176
            ff_tlog(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
            if (i > 62) {
                i -= 192;
                if (i & (~63)) {
                    av_log(s->avctx, AV_LOG_ERROR,
                           "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
                    return -1;
                }

                block[scan_table[i]] = level;
                break;
1187 1188 1189 1190
            }

            block[scan_table[i]] = level;
        }
1191
        CLOSE_READER(re, &s->gb);
1192
    }
1193 1194

not_coded:
1195
    if (intra) {
1196
        if (!ctx->use_intra_dc_vlc) {
1197 1198
            block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);

1199
            i -= i >> 31;  // if (i == -1) i = 0;
1200 1201
        }

1202
        ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1203 1204
        if (s->ac_pred)
            i = 63;  // FIXME not optimal
1205 1206 1207 1208 1209 1210 1211 1212 1213
    }
    s->block_last_index[n] = i;
    return 0;
}

/**
 * decode partition C of one MB.
 * @return <0 if an error occurred
 */
Diego Biurrun's avatar
Diego Biurrun committed
1214
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
1215
{
1216
    Mpeg4DecContext *ctx = (Mpeg4DecContext *)s;
1217
    int cbp, mb_type;
1218
    const int xy = s->mb_x + s->mb_y * s->mb_stride;
1219

1220
    mb_type = s->current_picture.mb_type[xy];
1221
    cbp     = s->cbp_table[xy];
1222

1223
    ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1224

1225
    if (s->current_picture.qscale_table[xy] != s->qscale)
1226
        ff_set_qscale(s, s->current_picture.qscale_table[xy]);
1227

1228 1229
    if (s->pict_type == AV_PICTURE_TYPE_P ||
        s->pict_type == AV_PICTURE_TYPE_S) {
1230
        int i;
1231
        for (i = 0; i < 4; i++) {
1232 1233
            s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
            s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
1234 1235 1236 1237 1238
        }
        s->mb_intra = IS_INTRA(mb_type);

        if (IS_SKIP(mb_type)) {
            /* skip mb */
1239
            for (i = 0; i < 6; i++)
1240
                s->block_last_index[i] = -1;
1241
            s->mv_dir  = MV_DIR_FORWARD;
1242
            s->mv_type = MV_TYPE_16X16;
1243
            if (s->pict_type == AV_PICTURE_TYPE_S
1244
                && ctx->vol_sprite_usage == GMC_SPRITE) {
1245
                s->mcsel      = 1;
1246
                s->mb_skipped = 0;
1247 1248
            } else {
                s->mcsel      = 0;
1249 1250
                s->mb_skipped = 1;
            }
1251
        } else if (s->mb_intra) {
1252
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
1253 1254
        } else if (!s->mb_intra) {
            // s->mcsel = 0;  // FIXME do we need to init that?
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264

            s->mv_dir = MV_DIR_FORWARD;
            if (IS_8X8(mb_type)) {
                s->mv_type = MV_TYPE_8X8;
            } else {
                s->mv_type = MV_TYPE_16X16;
            }
        }
    } else { /* I-Frame */
        s->mb_intra = 1;
1265
        s->ac_pred  = IS_ACPRED(s->current_picture.mb_type[xy]);
1266 1267 1268 1269
    }

    if (!IS_SKIP(mb_type)) {
        int i;
1270
        s->bdsp.clear_blocks(s->block[0]);
1271 1272
        /* decode each block */
        for (i = 0; i < 6; i++) {
1273
            if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, s->mb_intra, ctx->rvlc) < 0) {
1274 1275 1276
                av_log(s->avctx, AV_LOG_ERROR,
                       "texture corrupted at %d %d %d\n",
                       s->mb_x, s->mb_y, s->mb_intra);
1277 1278
                return -1;
            }
1279
            cbp += cbp;
1280 1281 1282 1283
        }
    }

    /* per-MB end of slice check */
1284
    if (--s->mb_num_left <= 0) {
1285
        if (mpeg4_is_resync(ctx))
1286 1287 1288
            return SLICE_END;
        else
            return SLICE_NOEND;
1289
    } else {
1290
        if (mpeg4_is_resync(ctx)) {
1291 1292
            const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
            if (s->cbp_table[xy + delta])
1293 1294 1295 1296 1297 1298
                return SLICE_END;
        }
        return SLICE_OK;
    }
}

1299
static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
1300
{
1301
    Mpeg4DecContext *ctx = (Mpeg4DecContext *)s;
1302 1303
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
    int16_t *mot_val;
1304
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1305
    const int xy = s->mb_x + s->mb_y * s->mb_stride;
1306

1307
    av_assert2(s->h263_pred);
1308

1309 1310 1311
    if (s->pict_type == AV_PICTURE_TYPE_P ||
        s->pict_type == AV_PICTURE_TYPE_S) {
        do {
1312 1313 1314
            if (get_bits1(&s->gb)) {
                /* skip mb */
                s->mb_intra = 0;
1315
                for (i = 0; i < 6; i++)
1316
                    s->block_last_index[i] = -1;
1317
                s->mv_dir  = MV_DIR_FORWARD;
1318
                s->mv_type = MV_TYPE_16X16;
1319
                if (s->pict_type == AV_PICTURE_TYPE_S &&
1320
                    ctx->vol_sprite_usage == GMC_SPRITE) {
1321 1322 1323 1324 1325
                    s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                     MB_TYPE_GMC   |
                                                     MB_TYPE_16x16 |
                                                     MB_TYPE_L0;
                    s->mcsel       = 1;
1326 1327
                    s->mv[0][0][0] = get_amv(ctx, 0);
                    s->mv[0][0][1] = get_amv(ctx, 1);
1328 1329 1330 1331 1332 1333
                    s->mb_skipped  = 0;
                } else {
                    s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                     MB_TYPE_16x16 |
                                                     MB_TYPE_L0;
                    s->mcsel       = 0;
1334 1335
                    s->mv[0][0][0] = 0;
                    s->mv[0][0][1] = 0;
1336
                    s->mb_skipped  = 1;
1337 1338 1339
                }
                goto end;
            }
1340
            cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1341 1342
            if (cbpc < 0) {
                av_log(s->avctx, AV_LOG_ERROR,
1343
                       "mcbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1344 1345
                return -1;
            }
1346
        } while (cbpc == 20);
1347

1348
        s->bdsp.clear_blocks(s->block[0]);
1349
        dquant      = cbpc & 8;
1350
        s->mb_intra = ((cbpc & 4) != 0);
1351 1352
        if (s->mb_intra)
            goto intra;
1353

1354
        if (s->pict_type == AV_PICTURE_TYPE_S &&
1355
            ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
1356 1357 1358
            s->mcsel = get_bits1(&s->gb);
        else
            s->mcsel = 0;
1359
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
1360 1361 1362 1363 1364
        if (cbpy < 0) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "P cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
            return AVERROR_INVALIDDATA;
        }
1365 1366

        cbp = (cbpc & 3) | (cbpy << 2);
1367
        if (dquant)
1368
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1369 1370 1371
        if ((!s->progressive_sequence) &&
            (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE)))
            s->interlaced_dct = get_bits1(&s->gb);
1372 1373 1374

        s->mv_dir = MV_DIR_FORWARD;
        if ((cbpc & 16) == 0) {
1375 1376 1377 1378
            if (s->mcsel) {
                s->current_picture.mb_type[xy] = MB_TYPE_GMC   |
                                                 MB_TYPE_16x16 |
                                                 MB_TYPE_L0;
1379
                /* 16x16 global motion prediction */
1380
                s->mv_type     = MV_TYPE_16X16;
1381 1382
                mx             = get_amv(ctx, 0);
                my             = get_amv(ctx, 1);
1383 1384
                s->mv[0][0][0] = mx;
                s->mv[0][0][1] = my;
1385 1386 1387 1388
            } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
                s->current_picture.mb_type[xy] = MB_TYPE_16x8 |
                                                 MB_TYPE_L0   |
                                                 MB_TYPE_INTERLACED;
1389
                /* 16x8 field motion prediction */
1390
                s->mv_type = MV_TYPE_FIELD;
1391

1392 1393
                s->field_select[0][0] = get_bits1(&s->gb);
                s->field_select[0][1] = get_bits1(&s->gb);
1394

1395
                ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1396

1397
                for (i = 0; i < 2; i++) {
1398
                    mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1399 1400 1401
                    if (mx >= 0xffff)
                        return -1;

1402
                    my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
1403 1404 1405 1406 1407 1408
                    if (my >= 0xffff)
                        return -1;

                    s->mv[0][i][0] = mx;
                    s->mv[0][i][1] = my;
                }
1409
            } else {
1410
                s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
1411 1412
                /* 16x16 motion prediction */
                s->mv_type = MV_TYPE_16X16;
1413 1414
                ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
                mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1415 1416 1417 1418

                if (mx >= 0xffff)
                    return -1;

1419
                my = ff_h263_decode_motion(s, pred_y, s->f_code);
1420 1421 1422 1423 1424 1425 1426

                if (my >= 0xffff)
                    return -1;
                s->mv[0][0][0] = mx;
                s->mv[0][0][1] = my;
            }
        } else {
1427
            s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
1428 1429
            s->mv_type                     = MV_TYPE_8X8;
            for (i = 0; i < 4; i++) {
1430
                mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1431
                mx      = ff_h263_decode_motion(s, pred_x, s->f_code);
1432 1433 1434
                if (mx >= 0xffff)
                    return -1;

1435
                my = ff_h263_decode_motion(s, pred_y, s->f_code);
1436 1437 1438 1439
                if (my >= 0xffff)
                    return -1;
                s->mv[0][i][0] = mx;
                s->mv[0][i][1] = my;
1440 1441
                mot_val[0]     = mx;
                mot_val[1]     = my;
1442 1443
            }
        }
1444 1445 1446
    } else if (s->pict_type == AV_PICTURE_TYPE_B) {
        int modb1;   // first bit of modb
        int modb2;   // second bit of modb
1447 1448
        int mb_type;

1449 1450
        s->mb_intra = 0;  // B-frames never contain intra blocks
        s->mcsel    = 0;  //      ...               true gmc blocks
1451

1452 1453 1454 1455 1456 1457
        if (s->mb_x == 0) {
            for (i = 0; i < 2; i++) {
                s->last_mv[i][0][0] =
                s->last_mv[i][0][1] =
                s->last_mv[i][1][0] =
                s->last_mv[i][1][1] = 0;
1458
            }
1459

1460
            ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);
1461 1462
        }

1463
        /* if we skipped it in the future P-frame than skip it now too */
1464
        s->mb_skipped = s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x];  // Note, skiptab=0 if last was GMC
1465

1466 1467 1468
        if (s->mb_skipped) {
            /* skip mb */
            for (i = 0; i < 6; i++)
1469 1470
                s->block_last_index[i] = -1;

1471 1472 1473 1474 1475
            s->mv_dir      = MV_DIR_FORWARD;
            s->mv_type     = MV_TYPE_16X16;
            s->mv[0][0][0] =
            s->mv[0][0][1] =
            s->mv[1][0][0] =
1476
            s->mv[1][0][1] = 0;
1477 1478 1479
            s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                             MB_TYPE_16x16 |
                                             MB_TYPE_L0;
1480 1481 1482
            goto end;
        }

1483 1484 1485 1486 1487 1488 1489 1490 1491
        modb1 = get_bits1(&s->gb);
        if (modb1) {
            // like MB_TYPE_B_DIRECT but no vectors coded
            mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1;
            cbp     = 0;
        } else {
            modb2   = get_bits1(&s->gb);
            mb_type = get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
            if (mb_type < 0) {
1492 1493 1494
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
                return -1;
            }
1495 1496 1497 1498
            mb_type = mb_type_b_map[mb_type];
            if (modb2) {
                cbp = 0;
            } else {
1499
                s->bdsp.clear_blocks(s->block[0]);
1500
                cbp = get_bits(&s->gb, 6);
1501 1502 1503
            }

            if ((!IS_DIRECT(mb_type)) && cbp) {
1504 1505
                if (get_bits1(&s->gb))
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2);
1506 1507
            }

1508 1509 1510
            if (!s->progressive_sequence) {
                if (cbp)
                    s->interlaced_dct = get_bits1(&s->gb);
1511

1512
                if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) {
1513 1514 1515
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
                    mb_type &= ~MB_TYPE_16x16;

1516 1517 1518
                    if (USES_LIST(mb_type, 0)) {
                        s->field_select[0][0] = get_bits1(&s->gb);
                        s->field_select[0][1] = get_bits1(&s->gb);
1519
                    }
1520 1521 1522
                    if (USES_LIST(mb_type, 1)) {
                        s->field_select[1][0] = get_bits1(&s->gb);
                        s->field_select[1][1] = get_bits1(&s->gb);
1523 1524 1525 1526 1527
                    }
                }
            }

            s->mv_dir = 0;
1528 1529
            if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) {
                s->mv_type = MV_TYPE_16X16;
1530

1531
                if (USES_LIST(mb_type, 0)) {
1532 1533
                    s->mv_dir = MV_DIR_FORWARD;

1534 1535
                    mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
                    my = ff_h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1536 1537 1538 1539 1540 1541
                    s->last_mv[0][1][0] =
                    s->last_mv[0][0][0] =
                    s->mv[0][0][0]      = mx;
                    s->last_mv[0][1][1] =
                    s->last_mv[0][0][1] =
                    s->mv[0][0][1]      = my;
1542 1543
                }

1544
                if (USES_LIST(mb_type, 1)) {
1545 1546
                    s->mv_dir |= MV_DIR_BACKWARD;

1547 1548
                    mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
                    my = ff_h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1549 1550 1551 1552 1553 1554
                    s->last_mv[1][1][0] =
                    s->last_mv[1][0][0] =
                    s->mv[1][0][0]      = mx;
                    s->last_mv[1][1][1] =
                    s->last_mv[1][0][1] =
                    s->mv[1][0][1]      = my;
1555
                }
1556 1557
            } else if (!IS_DIRECT(mb_type)) {
                s->mv_type = MV_TYPE_FIELD;
1558

1559
                if (USES_LIST(mb_type, 0)) {
1560 1561
                    s->mv_dir = MV_DIR_FORWARD;

1562 1563 1564 1565 1566 1567
                    for (i = 0; i < 2; i++) {
                        mx = ff_h263_decode_motion(s, s->last_mv[0][i][0], s->f_code);
                        my = ff_h263_decode_motion(s, s->last_mv[0][i][1] / 2, s->f_code);
                        s->last_mv[0][i][0] =
                        s->mv[0][i][0]      = mx;
                        s->last_mv[0][i][1] = (s->mv[0][i][1] = my) * 2;
1568 1569 1570
                    }
                }

1571
                if (USES_LIST(mb_type, 1)) {
1572 1573
                    s->mv_dir |= MV_DIR_BACKWARD;

1574 1575 1576 1577 1578 1579
                    for (i = 0; i < 2; i++) {
                        mx = ff_h263_decode_motion(s, s->last_mv[1][i][0], s->b_code);
                        my = ff_h263_decode_motion(s, s->last_mv[1][i][1] / 2, s->b_code);
                        s->last_mv[1][i][0] =
                        s->mv[1][i][0]      = mx;
                        s->last_mv[1][i][1] = (s->mv[1][i][1] = my) * 2;
1580 1581 1582 1583 1584
                    }
                }
            }
        }

1585 1586 1587 1588 1589
        if (IS_DIRECT(mb_type)) {
            if (IS_SKIP(mb_type)) {
                mx =
                my = 0;
            } else {
1590 1591
                mx = ff_h263_decode_motion(s, 0, 1);
                my = ff_h263_decode_motion(s, 0, 1);
1592 1593 1594
            }

            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1595
            mb_type  |= ff_mpeg4_set_direct_mv(s, mx, my);
1596
        }
1597
        s->current_picture.mb_type[xy] = mb_type;
1598
    } else { /* I-Frame */
1599
        do {
1600
            cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1601 1602 1603
            if (cbpc < 0) {
                av_log(s->avctx, AV_LOG_ERROR,
                       "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1604 1605
                return -1;
            }
1606
        } while (cbpc == 8);
1607 1608 1609

        dquant = cbpc & 4;
        s->mb_intra = 1;
1610

1611 1612
intra:
        s->ac_pred = get_bits1(&s->gb);
1613
        if (s->ac_pred)
1614
            s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1615
        else
1616
            s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1617

1618
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1619 1620 1621
        if (cbpy < 0) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1622 1623 1624 1625
            return -1;
        }
        cbp = (cbpc & 3) | (cbpy << 2);

1626
        ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1627

1628
        if (dquant)
1629 1630
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);

1631 1632
        if (!s->progressive_sequence)
            s->interlaced_dct = get_bits1(&s->gb);
1633

1634
        s->bdsp.clear_blocks(s->block[0]);
1635 1636
        /* decode each block */
        for (i = 0; i < 6; i++) {
1637
            if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 1, 0) < 0)
1638
                return -1;
1639
            cbp += cbp;
1640 1641 1642 1643 1644 1645
        }
        goto end;
    }

    /* decode each block */
    for (i = 0; i < 6; i++) {
1646
        if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 0, 0) < 0)
1647
            return -1;
1648
        cbp += cbp;
1649 1650
    }

1651 1652 1653
end:
    /* per-MB end of slice check */
    if (s->codec_id == AV_CODEC_ID_MPEG4) {
1654
        int next = mpeg4_is_resync(ctx);
1655
        if (next) {
1656
            if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
1657 1658 1659
                return -1;
            } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
                return SLICE_END;
1660

1661
            if (s->pict_type == AV_PICTURE_TYPE_B) {
1662
                const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1663
                ff_thread_await_progress(&s->next_picture_ptr->tf,
1664 1665 1666
                                         (s->mb_x + delta >= s->mb_width)
                                         ? FFMIN(s->mb_y + 1, s->mb_height - 1)
                                         : s->mb_y, 0);
1667
                if (s->next_picture.mbskip_table[xy + delta])
1668 1669 1670 1671
                    return SLICE_OK;
            }

            return SLICE_END;
1672 1673 1674 1675 1676 1677
        }
    }

    return SLICE_OK;
}

1678 1679
static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
{
1680 1681
    int hours, minutes, seconds;

1682
    if (!show_bits(gb, 23)) {
1683 1684 1685 1686
        av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
        return -1;
    }

1687 1688
    hours   = get_bits(gb, 5);
    minutes = get_bits(gb, 6);
1689
    check_marker(s->avctx, gb, "in gop_header");
1690
    seconds = get_bits(gb, 6);
1691

1692
    s->time_base = seconds + 60*(minutes + 60*hours);
1693 1694 1695 1696 1697 1698 1699

    skip_bits1(gb);
    skip_bits1(gb);

    return 0;
}

1700 1701
static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb)
{
1702

1703 1704
    s->avctx->profile = get_bits(gb, 4);
    s->avctx->level   = get_bits(gb, 4);
1705

1706 1707 1708 1709
    // for Simple profile, level 0
    if (s->avctx->profile == 0 && s->avctx->level == 8) {
        s->avctx->level = 0;
    }
1710

1711
    return 0;
1712 1713
}

1714
static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
1715
{
1716
    MpegEncContext *s = &ctx->m;
1717 1718 1719
    int width, height, vo_ver_id;

    /* vol header */
1720 1721 1722 1723 1724
    skip_bits(gb, 1);                   /* random access */
    s->vo_type = get_bits(gb, 8);
    if (get_bits1(gb) != 0) {           /* is_ol_id */
        vo_ver_id = get_bits(gb, 4);    /* vo_ver_id */
        skip_bits(gb, 3);               /* vo_priority */
1725 1726 1727
    } else {
        vo_ver_id = 1;
    }
1728 1729 1730 1731 1732 1733
    s->aspect_ratio_info = get_bits(gb, 4);
    if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
        s->avctx->sample_aspect_ratio.num = get_bits(gb, 8);  // par_width
        s->avctx->sample_aspect_ratio.den = get_bits(gb, 8);  // par_height
    } else {
        s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[s->aspect_ratio_info];
1734 1735
    }

1736
    if ((ctx->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
1737 1738
        int chroma_format = get_bits(gb, 2);
        if (chroma_format != CHROMA_420)
1739
            av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
1740 1741 1742

        s->low_delay = get_bits1(gb);
        if (get_bits1(gb)) {    /* vbv parameters */
1743
            get_bits(gb, 15);   /* first_half_bitrate */
1744
            check_marker(s->avctx, gb, "after first_half_bitrate");
1745
            get_bits(gb, 15);   /* latter_half_bitrate */
1746
            check_marker(s->avctx, gb, "after latter_half_bitrate");
1747
            get_bits(gb, 15);   /* first_half_vbv_buffer_size */
1748
            check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
1749 1750
            get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
            get_bits(gb, 11);   /* first_half_vbv_occupancy */
1751
            check_marker(s->avctx, gb, "after first_half_vbv_occupancy");
1752
            get_bits(gb, 15);   /* latter_half_vbv_occupancy */
1753
            check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
1754
        }
1755 1756
    } else {
        /* is setting low delay flag only once the smartest thing to do?
1757
         * low delay detection will not be overridden. */
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
        if (s->picture_number == 0) {
            switch(s->vo_type) {
            case SIMPLE_VO_TYPE:
            case ADV_SIMPLE_VO_TYPE:
                s->low_delay = 1;
                break;
            default:
                s->low_delay = 0;
            }
        }
1768 1769
    }

1770 1771
    ctx->shape = get_bits(gb, 2); /* vol shape */
    if (ctx->shape != RECT_SHAPE)
1772
        av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
1773
    if (ctx->shape == GRAY_SHAPE && vo_ver_id != 1) {
1774
        av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
1775
        skip_bits(gb, 4);  /* video_object_layer_shape_extension */
1776 1777
    }

1778
    check_marker(s->avctx, gb, "before time_increment_resolution");
1779

1780 1781 1782
    s->avctx->framerate.num = get_bits(gb, 16);
    if (!s->avctx->framerate.num) {
        av_log(s->avctx, AV_LOG_ERROR, "framerate==0\n");
1783
        return AVERROR_INVALIDDATA;
1784 1785
    }

1786
    ctx->time_increment_bits = av_log2(s->avctx->framerate.num - 1) + 1;
1787 1788
    if (ctx->time_increment_bits < 1)
        ctx->time_increment_bits = 1;
1789

1790
    check_marker(s->avctx, gb, "before fixed_vop_rate");
1791

1792
    if (get_bits1(gb) != 0)     /* fixed_vop_rate  */
1793
        s->avctx->framerate.den = get_bits(gb, ctx->time_increment_bits);
1794
    else
1795
        s->avctx->framerate.den = 1;
1796

1797
    s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
1798

1799
    ctx->t_frame = 0;
1800

1801 1802
    if (ctx->shape != BIN_ONLY_SHAPE) {
        if (ctx->shape == RECT_SHAPE) {
1803
            check_marker(s->avctx, gb, "before width");
1804
            width = get_bits(gb, 13);
1805
            check_marker(s->avctx, gb, "before height");
1806
            height = get_bits(gb, 13);
1807
            check_marker(s->avctx, gb, "after height");
1808 1809
            if (width && height &&  /* they should be non zero but who knows */
                !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
1810 1811 1812
                if (s->width && s->height &&
                    (s->width != width || s->height != height))
                    s->context_reinit = 1;
1813
                s->width  = width;
1814 1815 1816 1817
                s->height = height;
            }
        }

1818 1819 1820 1821 1822
        s->progressive_sequence  =
        s->progressive_frame     = get_bits1(gb) ^ 1;
        s->interlaced_dct        = 0;
        if (!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
            av_log(s->avctx, AV_LOG_INFO,           /* OBMC Disable */
1823
                   "MPEG-4 OBMC not supported (very likely buggy encoder)\n");
1824
        if (vo_ver_id == 1)
1825
            ctx->vol_sprite_usage = get_bits1(gb);    /* vol_sprite_usage */
1826
        else
1827
            ctx->vol_sprite_usage = get_bits(gb, 2);  /* vol_sprite_usage */
1828

1829
        if (ctx->vol_sprite_usage == STATIC_SPRITE)
1830
            av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
1831 1832 1833
        if (ctx->vol_sprite_usage == STATIC_SPRITE ||
            ctx->vol_sprite_usage == GMC_SPRITE) {
            if (ctx->vol_sprite_usage == STATIC_SPRITE) {
1834
                skip_bits(gb, 13); // sprite_width
1835
                check_marker(s->avctx, gb, "after sprite_width");
1836
                skip_bits(gb, 13); // sprite_height
1837
                check_marker(s->avctx, gb, "after sprite_height");
1838
                skip_bits(gb, 13); // sprite_left
1839
                check_marker(s->avctx, gb, "after sprite_left");
1840
                skip_bits(gb, 13); // sprite_top
1841
                check_marker(s->avctx, gb, "after sprite_top");
1842
            }
1843 1844
            ctx->num_sprite_warping_points = get_bits(gb, 6);
            if (ctx->num_sprite_warping_points > 3) {
1845 1846
                av_log(s->avctx, AV_LOG_ERROR,
                       "%d sprite_warping_points\n",
1847 1848
                       ctx->num_sprite_warping_points);
                ctx->num_sprite_warping_points = 0;
1849
                return AVERROR_INVALIDDATA;
1850
            }
1851
            s->sprite_warping_accuracy  = get_bits(gb, 2);
1852
            ctx->sprite_brightness_change = get_bits1(gb);
1853
            if (ctx->vol_sprite_usage == STATIC_SPRITE)
1854
                skip_bits1(gb); // low_latency_sprite
1855 1856 1857
        }
        // FIXME sadct disable bit if verid!=1 && shape not rect

1858 1859 1860 1861 1862 1863 1864
        if (get_bits1(gb) == 1) {                   /* not_8_bit */
            s->quant_precision = get_bits(gb, 4);   /* quant_precision */
            if (get_bits(gb, 4) != 8)               /* bits_per_pixel */
                av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
            if (s->quant_precision != 5)
                av_log(s->avctx, AV_LOG_ERROR,
                       "quant precision %d\n", s->quant_precision);
1865
            if (s->quant_precision<3 || s->quant_precision>9) {
1866 1867
                s->quant_precision = 5;
            }
1868 1869 1870 1871 1872 1873
        } else {
            s->quant_precision = 5;
        }

        // FIXME a bunch of grayscale shape things

1874
        if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
1875 1876 1877
            int i, v;

            /* load default matrixes */
1878
            for (i = 0; i < 64; i++) {
1879
                int j = s->idsp.idct_permutation[i];
1880 1881 1882 1883 1884 1885 1886
                v = ff_mpeg4_default_intra_matrix[i];
                s->intra_matrix[j]        = v;
                s->chroma_intra_matrix[j] = v;

                v = ff_mpeg4_default_non_intra_matrix[i];
                s->inter_matrix[j]        = v;
                s->chroma_inter_matrix[j] = v;
1887 1888 1889
            }

            /* load custom intra matrix */
1890 1891 1892
            if (get_bits1(gb)) {
                int last = 0;
                for (i = 0; i < 64; i++) {
1893
                    int j;
1894 1895 1896 1897
                    if (get_bits_left(gb) < 8) {
                        av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
                        return AVERROR_INVALIDDATA;
                    }
1898 1899 1900 1901 1902
                    v = get_bits(gb, 8);
                    if (v == 0)
                        break;

                    last = v;
1903
                    j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1904 1905
                    s->intra_matrix[j]        = last;
                    s->chroma_intra_matrix[j] = last;
1906 1907 1908
                }

                /* replicate last value */
1909
                for (; i < 64; i++) {
1910
                    int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1911 1912
                    s->intra_matrix[j]        = last;
                    s->chroma_intra_matrix[j] = last;
1913 1914 1915 1916
                }
            }

            /* load custom non intra matrix */
1917 1918 1919
            if (get_bits1(gb)) {
                int last = 0;
                for (i = 0; i < 64; i++) {
1920
                    int j;
1921 1922 1923 1924
                    if (get_bits_left(gb) < 8) {
                        av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
                        return AVERROR_INVALIDDATA;
                    }
1925 1926 1927 1928 1929
                    v = get_bits(gb, 8);
                    if (v == 0)
                        break;

                    last = v;
1930
                    j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1931 1932
                    s->inter_matrix[j]        = v;
                    s->chroma_inter_matrix[j] = v;
1933 1934 1935
                }

                /* replicate last value */
1936
                for (; i < 64; i++) {
1937
                    int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1938 1939
                    s->inter_matrix[j]        = last;
                    s->chroma_inter_matrix[j] = last;
1940 1941 1942 1943 1944 1945
                }
            }

            // FIXME a bunch of grayscale shape things
        }

1946 1947 1948 1949 1950
        if (vo_ver_id != 1)
            s->quarter_sample = get_bits1(gb);
        else
            s->quarter_sample = 0;

1951 1952 1953 1954 1955
        if (get_bits_left(gb) < 4) {
            av_log(s->avctx, AV_LOG_ERROR, "VOL Header truncated\n");
            return AVERROR_INVALIDDATA;
        }

1956 1957 1958 1959 1960
        if (!get_bits1(gb)) {
            int pos               = get_bits_count(gb);
            int estimation_method = get_bits(gb, 2);
            if (estimation_method < 2) {
                if (!get_bits1(gb)) {
1961 1962 1963 1964 1965
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* opaque */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* transparent */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* intra_cae */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* inter_cae */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* no_update */
1966
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* upsampling */
1967
                }
1968
                if (!get_bits1(gb)) {
1969 1970 1971 1972
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* intra_blocks */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* inter_blocks */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* inter4v_blocks */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* not coded blocks */
1973
                }
1974
                if (!check_marker(s->avctx, gb, "in complexity estimation part 1")) {
1975 1976 1977
                    skip_bits_long(gb, pos - get_bits_count(gb));
                    goto no_cplx_est;
                }
1978
                if (!get_bits1(gb)) {
1979 1980 1981 1982
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* dct_coeffs */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* dct_lines */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* vlc_syms */
                    ctx->cplx_estimation_trash_i += 4 * get_bits1(gb);  /* vlc_bits */
1983
                }
1984
                if (!get_bits1(gb)) {
1985 1986 1987 1988 1989 1990
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* apm */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* npm */
                    ctx->cplx_estimation_trash_b += 8 * get_bits1(gb);  /* interpolate_mc_q */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* forwback_mc_q */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* halfpel2 */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* halfpel4 */
1991
                }
1992
                if (!check_marker(s->avctx, gb, "in complexity estimation part 2")) {
1993 1994 1995
                    skip_bits_long(gb, pos - get_bits_count(gb));
                    goto no_cplx_est;
                }
1996
                if (estimation_method == 1) {
1997 1998
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* sadct */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* qpel */
1999
                }
2000 2001 2002 2003 2004 2005
            } else
                av_log(s->avctx, AV_LOG_ERROR,
                       "Invalid Complexity estimation method %d\n",
                       estimation_method);
        } else {

2006
no_cplx_est:
2007 2008 2009
            ctx->cplx_estimation_trash_i =
            ctx->cplx_estimation_trash_p =
            ctx->cplx_estimation_trash_b = 0;
2010 2011
        }

2012
        ctx->resync_marker = !get_bits1(gb); /* resync_marker_disabled */
2013

2014 2015
        s->data_partitioning = get_bits1(gb);
        if (s->data_partitioning)
2016
            ctx->rvlc = get_bits1(gb);
2017

2018
        if (vo_ver_id != 1) {
2019 2020
            ctx->new_pred = get_bits1(gb);
            if (ctx->new_pred) {
2021 2022
                av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
                skip_bits(gb, 2); /* requested upstream message type */
2023
                skip_bits1(gb);   /* newpred segment type */
2024
            }
2025
            if (get_bits1(gb)) // reduced_res_vop
2026 2027 2028
                av_log(s->avctx, AV_LOG_ERROR,
                       "reduced resolution VOP not supported\n");
        } else {
2029
            ctx->new_pred = 0;
2030 2031
        }

2032
        ctx->scalability = get_bits1(gb);
2033

2034
        if (ctx->scalability) {
2035
            GetBitContext bak = *gb;
2036 2037 2038 2039 2040
            int h_sampling_factor_n;
            int h_sampling_factor_m;
            int v_sampling_factor_n;
            int v_sampling_factor_m;

2041
            skip_bits1(gb);    // hierarchy_type
Mans Rullgard's avatar
Mans Rullgard committed
2042 2043
            skip_bits(gb, 4);  /* ref_layer_id */
            skip_bits1(gb);    /* ref_layer_sampling_dir */
2044 2045 2046 2047
            h_sampling_factor_n = get_bits(gb, 5);
            h_sampling_factor_m = get_bits(gb, 5);
            v_sampling_factor_n = get_bits(gb, 5);
            v_sampling_factor_m = get_bits(gb, 5);
2048
            ctx->enhancement_type = get_bits1(gb);
2049 2050 2051

            if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
                v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2052 2053
                /* illegal scalability header (VERY broken encoder),
                 * trying to workaround */
2054
                ctx->scalability = 0;
2055 2056
                *gb            = bak;
            } else
2057 2058 2059 2060 2061
                av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");

            // bin shape stuff FIXME
        }
    }
2062

2063
    if (s->avctx->debug&FF_DEBUG_PICT_INFO) {
2064
        av_log(s->avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d, low_delay:%d  %s%s%s%s\n",
2065
               s->avctx->framerate.den, s->avctx->framerate.num,
2066
               ctx->time_increment_bits,
2067 2068
               s->quant_precision,
               s->progressive_sequence,
2069
               s->low_delay,
2070
               ctx->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "",
2071
               s->data_partitioning ? "partition " : "", ctx->rvlc ? "rvlc " : ""
2072 2073 2074
        );
    }

2075 2076 2077 2078
    return 0;
}

/**
2079
 * Decode the user data stuff in the header.
2080 2081
 * Also initializes divx/xvid/lavc_version/build.
 */
2082
static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
2083
{
2084
    MpegEncContext *s = &ctx->m;
2085 2086 2087 2088 2089 2090
    char buf[256];
    int i;
    int e;
    int ver = 0, build = 0, ver2 = 0, ver3 = 0;
    char last;

2091 2092 2093 2094
    for (i = 0; i < 255 && get_bits_count(gb) < gb->size_in_bits; i++) {
        if (show_bits(gb, 23) == 0)
            break;
        buf[i] = get_bits(gb, 8);
2095
    }
2096
    buf[i] = 0;
2097 2098

    /* divx detection */
2099 2100 2101 2102
    e = sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
    if (e < 2)
        e = sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
    if (e >= 2) {
2103 2104
        ctx->divx_version = ver;
        ctx->divx_build   = build;
2105
        s->divx_packed  = e == 3 && last == 'p';
2106 2107
    }

2108
    /* libavcodec detection */
2109 2110 2111 2112 2113 2114 2115
    e = sscanf(buf, "FFmpe%*[^b]b%d", &build) + 3;
    if (e != 4)
        e = sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
    if (e != 4) {
        e = sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1;
        if (e > 1)
            build = (ver << 16) + (ver2 << 8) + ver3;
2116
    }
2117 2118
    if (e != 4) {
        if (strcmp(buf, "ffmpeg") == 0)
2119
            ctx->lavc_build = 4600;
2120
    }
2121
    if (e == 4)
2122
        ctx->lavc_build = build;
2123 2124

    /* Xvid detection */
2125 2126
    e = sscanf(buf, "XviD%d", &build);
    if (e == 1)
2127
        ctx->xvid_build = build;
2128 2129 2130 2131

    return 0;
}

2132 2133 2134 2135 2136
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
{
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext *s = &ctx->m;

2137
    if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
2138
        if (s->codec_tag        == AV_RL32("XVID") ||
2139 2140 2141 2142
            s->codec_tag        == AV_RL32("XVIX") ||
            s->codec_tag        == AV_RL32("RMP4") ||
            s->codec_tag        == AV_RL32("ZMP4") ||
            s->codec_tag        == AV_RL32("SIPP"))
2143
            ctx->xvid_build = 0;
2144 2145
    }

2146
    if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
2147
        if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
2148
            ctx->vol_control_parameters == 0)
2149
            ctx->divx_version = 400;  // divx 4
2150

2151 2152 2153
    if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
        ctx->divx_version =
        ctx->divx_build   = -1;
2154 2155 2156 2157 2158 2159 2160 2161 2162
    }

    if (s->workaround_bugs & FF_BUG_AUTODETECT) {
        if (s->codec_tag == AV_RL32("XVIX"))
            s->workaround_bugs |= FF_BUG_XVID_ILACE;

        if (s->codec_tag == AV_RL32("UMP4"))
            s->workaround_bugs |= FF_BUG_UMP4;

2163
        if (ctx->divx_version >= 500 && ctx->divx_build < 1814)
2164 2165
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA;

2166
        if (ctx->divx_version > 502 && ctx->divx_build < 1814)
2167 2168
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA2;

2169
        if (ctx->xvid_build <= 3U)
2170 2171
            s->padding_bug_score = 256 * 256 * 256 * 64;

2172
        if (ctx->xvid_build <= 1U)
2173 2174
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA;

2175
        if (ctx->xvid_build <= 12U)
2176 2177
            s->workaround_bugs |= FF_BUG_EDGE;

2178
        if (ctx->xvid_build <= 32U)
2179 2180 2181
            s->workaround_bugs |= FF_BUG_DC_CLIP;

#define SET_QPEL_FUNC(postfix1, postfix2)                           \
2182 2183 2184
    s->qdsp.put_        ## postfix1 = ff_put_        ## postfix2;   \
    s->qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;   \
    s->qdsp.avg_        ## postfix1 = ff_avg_        ## postfix2;
2185

2186
        if (ctx->lavc_build < 4653U)
2187 2188
            s->workaround_bugs |= FF_BUG_STD_QPEL;

2189
        if (ctx->lavc_build < 4655U)
2190 2191
            s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;

2192
        if (ctx->lavc_build < 4670U)
2193 2194
            s->workaround_bugs |= FF_BUG_EDGE;

2195
        if (ctx->lavc_build <= 4712U)
2196 2197
            s->workaround_bugs |= FF_BUG_DC_CLIP;

2198
        if (ctx->divx_version >= 0)
2199
            s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
2200
        if (ctx->divx_version == 501 && ctx->divx_build == 20020416)
2201 2202
            s->padding_bug_score = 256 * 256 * 256 * 64;

2203
        if (ctx->divx_version < 500U)
2204 2205
            s->workaround_bugs |= FF_BUG_EDGE;

2206
        if (ctx->divx_version >= 0)
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
            s->workaround_bugs |= FF_BUG_HPEL_CHROMA;
    }

    if (s->workaround_bugs & FF_BUG_STD_QPEL) {
        SET_QPEL_FUNC(qpel_pixels_tab[0][5], qpel16_mc11_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][7], qpel16_mc31_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][9], qpel16_mc12_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][5], qpel8_mc11_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][7], qpel8_mc31_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][9], qpel8_mc12_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
    }

    if (avctx->debug & FF_DEBUG_BUGS)
        av_log(s->avctx, AV_LOG_DEBUG,
               "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
2229 2230
               s->workaround_bugs, ctx->lavc_build, ctx->xvid_build,
               ctx->divx_version, ctx->divx_build, s->divx_packed ? "p" : "");
2231

2232 2233
    if (CONFIG_MPEG4_DECODER && ctx->xvid_build >= 0 &&
        s->codec_id == AV_CODEC_ID_MPEG4 &&
2234
        avctx->idct_algo == FF_IDCT_AUTO) {
2235
        avctx->idct_algo = FF_IDCT_XVID;
2236
        ff_mpv_idct_init(s);
2237 2238
        return 1;
    }
2239

2240 2241 2242
    return 0;
}

2243
static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2244
{
2245
    MpegEncContext *s = &ctx->m;
2246
    int time_incr, time_increment;
2247
    int64_t pts;
2248

2249
    s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;        /* pict type: I = 0 , P = 1 */
2250
    if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
2251
        ctx->vol_control_parameters == 0 && !(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) {
2252
        av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
2253
        s->low_delay = 0;
2254 2255
    }

2256 2257 2258
    s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
    if (s->partitioned_frame)
        s->decode_mb = mpeg4_decode_partitioned_mb;
2259
    else
2260
        s->decode_mb = mpeg4_decode_mb;
2261

2262
    time_incr = 0;
2263 2264 2265
    while (get_bits1(gb) != 0)
        time_incr++;

2266
    check_marker(s->avctx, gb, "before time_increment");
2267

2268 2269
    if (ctx->time_increment_bits == 0 ||
        !(show_bits(gb, ctx->time_increment_bits + 1) & 1)) {
2270
        av_log(s->avctx, AV_LOG_WARNING,
2271
               "time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n", ctx->time_increment_bits);
2272

2273 2274 2275
        for (ctx->time_increment_bits = 1;
             ctx->time_increment_bits < 16;
             ctx->time_increment_bits++) {
2276 2277
            if (s->pict_type == AV_PICTURE_TYPE_P ||
                (s->pict_type == AV_PICTURE_TYPE_S &&
2278
                 ctx->vol_sprite_usage == GMC_SPRITE)) {
2279
                if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
2280
                    break;
2281
            } else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
2282
                break;
2283 2284
        }

2285
        av_log(s->avctx, AV_LOG_WARNING,
2286
               "time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits);
2287 2288 2289
        if (s->avctx->framerate.num && 4*s->avctx->framerate.num < 1<<ctx->time_increment_bits) {
            s->avctx->framerate.num = 1<<ctx->time_increment_bits;
            s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
2290
        }
2291 2292
    }

2293 2294 2295
    if (IS_3IV1)
        time_increment = get_bits1(gb);        // FIXME investigate further
    else
2296
        time_increment = get_bits(gb, ctx->time_increment_bits);
2297 2298 2299 2300

    if (s->pict_type != AV_PICTURE_TYPE_B) {
        s->last_time_base = s->time_base;
        s->time_base     += time_incr;
2301
        s->time = s->time_base * s->avctx->framerate.num + time_increment;
2302 2303
        if (s->workaround_bugs & FF_BUG_UMP4) {
            if (s->time < s->last_non_b_time) {
2304 2305 2306
                /* header is not mpeg-4-compatible, broken encoder,
                 * trying to workaround */
                s->time_base++;
2307
                s->time += s->avctx->framerate.num;
2308 2309
            }
        }
2310 2311 2312
        s->pp_time         = s->time - s->last_non_b_time;
        s->last_non_b_time = s->time;
    } else {
2313
        s->time    = (s->last_time_base + time_incr) * s->avctx->framerate.num + time_increment;
2314 2315 2316 2317
        s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
        if (s->pp_time <= s->pb_time ||
            s->pp_time <= s->pp_time - s->pb_time ||
            s->pp_time <= 0) {
2318
            /* messed up order, maybe after seeking? skipping current B-frame */
2319 2320 2321 2322
            return FRAME_SKIPPED;
        }
        ff_mpeg4_init_direct_mv(s);

2323 2324 2325 2326 2327 2328 2329 2330
        if (ctx->t_frame == 0)
            ctx->t_frame = s->pb_time;
        if (ctx->t_frame == 0)
            ctx->t_frame = 1;  // 1/0 protection
        s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, ctx->t_frame) -
                            ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
        s->pb_field_time = (ROUNDED_DIV(s->time, ctx->t_frame) -
                            ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
2331 2332 2333 2334
        if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) {
            s->pb_field_time = 2;
            s->pp_field_time = 4;
            if (!s->progressive_sequence)
2335 2336 2337 2338
                return FRAME_SKIPPED;
        }
    }

2339 2340
    if (s->avctx->framerate.den)
        pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
2341
    else
2342
        pts = AV_NOPTS_VALUE;
2343
    ff_dlog(s->avctx, "MPEG4 PTS: %"PRId64"\n", pts);
2344

2345
    check_marker(s->avctx, gb, "before vop_coded");
2346 2347

    /* vop coded */
2348 2349
    if (get_bits1(gb) != 1) {
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2350 2351 2352
            av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
        return FRAME_SKIPPED;
    }
2353
    if (ctx->new_pred)
2354
        decode_new_pred(ctx, gb);
2355

2356
    if (ctx->shape != BIN_ONLY_SHAPE &&
2357 2358
                    (s->pict_type == AV_PICTURE_TYPE_P ||
                     (s->pict_type == AV_PICTURE_TYPE_S &&
2359
                      ctx->vol_sprite_usage == GMC_SPRITE))) {
2360 2361 2362 2363 2364
        /* rounding type for motion estimation */
        s->no_rounding = get_bits1(gb);
    } else {
        s->no_rounding = 0;
    }
2365 2366
    // FIXME reduced res stuff

2367
    if (ctx->shape != RECT_SHAPE) {
2368
        if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
2369
            skip_bits(gb, 13);  /* width */
2370
            check_marker(s->avctx, gb, "after width");
2371
            skip_bits(gb, 13);  /* height */
2372
            check_marker(s->avctx, gb, "after height");
2373
            skip_bits(gb, 13);  /* hor_spat_ref */
2374
            check_marker(s->avctx, gb, "after hor_spat_ref");
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
            skip_bits(gb, 13);  /* ver_spat_ref */
        }
        skip_bits1(gb);         /* change_CR_disable */

        if (get_bits1(gb) != 0)
            skip_bits(gb, 8);   /* constant_alpha_value */
    }

    // FIXME complexity estimation stuff

2385
    if (ctx->shape != BIN_ONLY_SHAPE) {
2386
        skip_bits_long(gb, ctx->cplx_estimation_trash_i);
2387
        if (s->pict_type != AV_PICTURE_TYPE_I)
2388
            skip_bits_long(gb, ctx->cplx_estimation_trash_p);
2389
        if (s->pict_type == AV_PICTURE_TYPE_B)
2390
            skip_bits_long(gb, ctx->cplx_estimation_trash_b);
2391

2392 2393
        if (get_bits_left(gb) < 3) {
            av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
2394
            return AVERROR_INVALIDDATA;
2395
        }
2396
        ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
2397 2398 2399 2400 2401 2402 2403 2404
        if (!s->progressive_sequence) {
            s->top_field_first = get_bits1(gb);
            s->alternate_scan  = get_bits1(gb);
        } else
            s->alternate_scan = 0;
    }

    if (s->alternate_scan) {
2405 2406 2407 2408
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
2409
    } else {
2410 2411 2412 2413
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
2414 2415 2416
    }

    if (s->pict_type == AV_PICTURE_TYPE_S &&
2417 2418
        (ctx->vol_sprite_usage == STATIC_SPRITE ||
         ctx->vol_sprite_usage == GMC_SPRITE)) {
2419
        if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
2420
            return AVERROR_INVALIDDATA;
2421
        if (ctx->sprite_brightness_change)
2422 2423
            av_log(s->avctx, AV_LOG_ERROR,
                   "sprite_brightness_change not supported\n");
2424
        if (ctx->vol_sprite_usage == STATIC_SPRITE)
2425 2426 2427
            av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
    }

2428
    if (ctx->shape != BIN_ONLY_SHAPE) {
2429 2430 2431
        s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
        if (s->qscale == 0) {
            av_log(s->avctx, AV_LOG_ERROR,
2432
                   "Error, header damaged or not MPEG-4 header (qscale=0)\n");
2433
            return AVERROR_INVALIDDATA;  // makes no sense to continue, as there is nothing left from the image then
2434 2435 2436 2437 2438 2439
        }

        if (s->pict_type != AV_PICTURE_TYPE_I) {
            s->f_code = get_bits(gb, 3);        /* fcode_for */
            if (s->f_code == 0) {
                av_log(s->avctx, AV_LOG_ERROR,
2440
                       "Error, header damaged or not MPEG-4 header (f_code=0)\n");
2441
                s->f_code = 1;
2442
                return AVERROR_INVALIDDATA;  // makes no sense to continue, as there is nothing left from the image then
2443 2444 2445 2446 2447 2448
            }
        } else
            s->f_code = 1;

        if (s->pict_type == AV_PICTURE_TYPE_B) {
            s->b_code = get_bits(gb, 3);
2449 2450 2451 2452
            if (s->b_code == 0) {
                av_log(s->avctx, AV_LOG_ERROR,
                       "Error, header damaged or not MPEG4 header (b_code=0)\n");
                s->b_code=1;
2453
                return AVERROR_INVALIDDATA; // makes no sense to continue, as the MV decoding will break very quickly
2454
            }
2455 2456 2457 2458 2459
        } else
            s->b_code = 1;

        if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
            av_log(s->avctx, AV_LOG_DEBUG,
2460
                   "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64" tincr:%d\n",
2461 2462
                   s->qscale, s->f_code, s->b_code,
                   s->pict_type == AV_PICTURE_TYPE_I ? "I" : (s->pict_type == AV_PICTURE_TYPE_P ? "P" : (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
2463
                   gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
2464
                   s->top_field_first, s->quarter_sample ? "q" : "h",
2465
                   s->data_partitioning, ctx->resync_marker,
2466
                   ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
2467
                   1 - s->no_rounding, s->vo_type,
2468
                   ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
2469
                   ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
2470
                   ctx->cplx_estimation_trash_b,
2471 2472 2473
                   s->time,
                   time_increment
                  );
2474 2475
        }

2476
        if (!ctx->scalability) {
2477
            if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
2478 2479
                skip_bits1(gb);  // vop shape coding type
        } else {
2480
            if (ctx->enhancement_type) {
2481 2482 2483 2484 2485 2486 2487 2488 2489
                int load_backward_shape = get_bits1(gb);
                if (load_backward_shape)
                    av_log(s->avctx, AV_LOG_ERROR,
                           "load backward shape isn't supported\n");
            }
            skip_bits(gb, 2);  // ref_select_code
        }
    }
    /* detect buggy encoders which don't set the low_delay flag
2490
     * (divx4/xvid/opendivx). Note we cannot detect divx5 without B-frames
2491
     * easily (although it's buggy too) */
2492
    if (s->vo_type == 0 && ctx->vol_control_parameters == 0 &&
2493
        ctx->divx_version == -1 && s->picture_number == 0) {
2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509
        av_log(s->avctx, AV_LOG_WARNING,
               "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
        s->low_delay = 1;
    }

    s->picture_number++;  // better than pic number==0 always ;)

    // FIXME add short header support
    s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
    s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;

    if (s->workaround_bugs & FF_BUG_EDGE) {
        s->h_edge_pos = s->width;
        s->v_edge_pos = s->height;
    }
    return 0;
2510 2511 2512
}

/**
2513
 * Decode MPEG-4 headers.
2514 2515 2516 2517
 * @return <0 if no VOP found (or a damaged one)
 *         FRAME_SKIPPED if a not coded VOP is found
 *         0 if a VOP is found
 */
2518
int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2519
{
2520
    MpegEncContext *s = &ctx->m;
2521
    unsigned startcode, v;
2522
    int ret;
2523 2524 2525 2526

    /* search next start code */
    align_get_bits(gb);

2527
    if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
2528
        skip_bits(gb, 24);
2529
        if (get_bits(gb, 8) == 0xF0)
2530 2531 2532 2533
            goto end;
    }

    startcode = 0xff;
2534 2535 2536
    for (;;) {
        if (get_bits_count(gb) >= gb->size_in_bits) {
            if (gb->size_in_bits == 8 &&
2537
                (ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
2538
                av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
2539 2540 2541
                return FRAME_SKIPPED;  // divx bug
            } else
                return -1;  // end of stream
2542 2543 2544 2545 2546 2547
        }

        /* use the bits after the test */
        v = get_bits(gb, 8);
        startcode = ((startcode << 8) | v) & 0xffffffff;

2548 2549
        if ((startcode & 0xFFFFFF00) != 0x100)
            continue;  // no startcode
2550

2551
        if (s->avctx->debug & FF_DEBUG_STARTCODE) {
2552
            av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606
            if (startcode <= 0x11F)
                av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
            else if (startcode <= 0x12F)
                av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
            else if (startcode <= 0x13F)
                av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
            else if (startcode <= 0x15F)
                av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
            else if (startcode <= 0x1AF)
                av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
            else if (startcode == 0x1B0)
                av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
            else if (startcode == 0x1B1)
                av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
            else if (startcode == 0x1B2)
                av_log(s->avctx, AV_LOG_DEBUG, "User Data");
            else if (startcode == 0x1B3)
                av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
            else if (startcode == 0x1B4)
                av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
            else if (startcode == 0x1B5)
                av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
            else if (startcode == 0x1B6)
                av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
            else if (startcode == 0x1B7)
                av_log(s->avctx, AV_LOG_DEBUG, "slice start");
            else if (startcode == 0x1B8)
                av_log(s->avctx, AV_LOG_DEBUG, "extension start");
            else if (startcode == 0x1B9)
                av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
            else if (startcode == 0x1BA)
                av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
            else if (startcode == 0x1BB)
                av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
            else if (startcode == 0x1BC)
                av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
            else if (startcode == 0x1BD)
                av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
            else if (startcode == 0x1BE)
                av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
            else if (startcode == 0x1BF)
                av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
            else if (startcode == 0x1C0)
                av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
            else if (startcode == 0x1C1)
                av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
            else if (startcode == 0x1C2)
                av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
            else if (startcode == 0x1C3)
                av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
            else if (startcode <= 0x1C5)
                av_log(s->avctx, AV_LOG_DEBUG, "reserved");
            else if (startcode <= 0x1FF)
                av_log(s->avctx, AV_LOG_DEBUG, "System start");
2607 2608 2609
            av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
        }

2610
        if (startcode >= 0x120 && startcode <= 0x12F) {
2611 2612
            if ((ret = decode_vol_header(ctx, gb)) < 0)
                return ret;
2613
        } else if (startcode == USER_DATA_STARTCODE) {
2614
            decode_user_data(ctx, gb);
2615
        } else if (startcode == GOP_STARTCODE) {
2616
            mpeg4_decode_gop_header(s, gb);
2617
        } else if (startcode == VOS_STARTCODE) {
2618
            mpeg4_decode_profile_level(s, gb);
2619
        } else if (startcode == VOP_STARTCODE) {
2620 2621 2622 2623 2624 2625
            break;
        }

        align_get_bits(gb);
        startcode = 0xff;
    }
2626

2627
end:
2628
    if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2629 2630 2631
        s->low_delay = 1;
    s->avctx->has_b_frames = !s->low_delay;

2632
    return decode_vop_header(ctx, gb);
2633 2634
}

2635
av_cold void ff_mpeg4videodec_static_init(void) {
2636 2637 2638
    static int done = 0;

    if (!done) {
2639 2640 2641
        ff_rl_init(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
        ff_rl_init(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
        ff_rl_init(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
2642
        INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
2643 2644
        INIT_VLC_RL(ff_rvlc_rl_inter, 1072);
        INIT_VLC_RL(ff_rvlc_rl_intra, 1072);
2645
        INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2646 2647
                        &ff_mpeg4_DCtab_lum[0][1], 2, 1,
                        &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
2648
        INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2649 2650
                        &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
                        &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
2651
        INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2652 2653
                        &ff_sprite_trajectory_tab[0][1], 4, 2,
                        &ff_sprite_trajectory_tab[0][0], 4, 2, 128);
2654
        INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2655 2656
                        &ff_mb_type_b_tab[0][1], 2, 1,
                        &ff_mb_type_b_tab[0][0], 2, 1, 16);
2657
        done = 1;
2658
    }
2659 2660
}

2661 2662 2663 2664 2665
int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
{
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext    *s = &ctx->m;

2666 2667 2668
    /* divx 5.01+ bitstream reorder stuff */
    /* Since this clobbers the input buffer and hwaccel codecs still need the
     * data during hwaccel->end_frame we should not do this any earlier */
2669
    if (s->divx_packed) {
2670
        int current_pos     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);
2671 2672
        int startcode_found = 0;

2673 2674
        if (buf_size - current_pos > 7) {

2675
            int i;
2676 2677
            for (i = current_pos; i < buf_size - 4; i++)

2678 2679 2680 2681
                if (buf[i]     == 0 &&
                    buf[i + 1] == 0 &&
                    buf[i + 2] == 1 &&
                    buf[i + 3] == 0xB6) {
2682
                    startcode_found = !(buf[i + 4] & 0x40);
2683 2684 2685 2686 2687
                    break;
                }
        }

        if (startcode_found) {
2688 2689 2690
            if (!ctx->showed_packed_warning) {
                av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and "
                       "wasteful way to store B-frames ('packed B-frames'). "
2691
                       "Consider using the mpeg4_unpack_bframes bitstream filter without encoding but stream copy to fix it.\n");
2692 2693
                ctx->showed_packed_warning = 1;
            }
2694
            av_fast_padded_malloc(&s->bitstream_buffer,
2695
                           &s->allocated_bitstream_buffer_size,
2696
                           buf_size - current_pos);
2697 2698
            if (!s->bitstream_buffer) {
                s->bitstream_buffer_size = 0;
2699
                return AVERROR(ENOMEM);
2700
            }
2701 2702 2703 2704 2705 2706 2707 2708 2709
            memcpy(s->bitstream_buffer, buf + current_pos,
                   buf_size - current_pos);
            s->bitstream_buffer_size = buf_size - current_pos;
        }
    }

    return 0;
}

2710
#if HAVE_THREADS
2711 2712 2713 2714 2715
static int mpeg4_update_thread_context(AVCodecContext *dst,
                                       const AVCodecContext *src)
{
    Mpeg4DecContext *s = dst->priv_data;
    const Mpeg4DecContext *s1 = src->priv_data;
2716
    int init = s->m.context_initialized;
2717 2718 2719 2720 2721 2722

    int ret = ff_mpeg_update_thread_context(dst, src);

    if (ret < 0)
        return ret;

2723
    memcpy(((uint8_t*)s) + sizeof(MpegEncContext), ((uint8_t*)s1) + sizeof(MpegEncContext), sizeof(Mpeg4DecContext) - sizeof(MpegEncContext));
2724

2725
    if (CONFIG_MPEG4_DECODER && !init && s1->xvid_build >= 0)
2726
        ff_xvid_idct_init(&s->m.idsp, dst);
2727

2728 2729
    return 0;
}
2730
#endif
2731

2732 2733
static av_cold int decode_init(AVCodecContext *avctx)
{
2734 2735
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext *s = &ctx->m;
2736 2737
    int ret;

2738 2739 2740 2741
    ctx->divx_version =
    ctx->divx_build   =
    ctx->xvid_build   =
    ctx->lavc_build   = -1;
2742

2743
    if ((ret = ff_h263_decode_init(avctx)) < 0)
2744 2745 2746
        return ret;

    ff_mpeg4videodec_static_init();
2747 2748

    s->h263_pred = 1;
2749
    s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
2750
    s->decode_mb = mpeg4_decode_mb;
2751
    ctx->time_increment_bits = 4; /* default value for broken headers */
2752

2753
    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
2754 2755
    avctx->internal->allocate_progress = 1;

2756 2757 2758
    return 0;
}

2759
static const AVOption mpeg4_options[] = {
2760 2761
    {"quarter_sample", "1/4 subpel MC", offsetof(MpegEncContext, quarter_sample), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
    {"divx_packed", "divx style packed b frames", offsetof(MpegEncContext, divx_packed), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
    {NULL}
};

static const AVClass mpeg4_class = {
    "MPEG4 Video Decoder",
    av_default_item_name,
    mpeg4_options,
    LIBAVUTIL_VERSION_INT,
};

2772
AVCodec ff_mpeg4_decoder = {
2773
    .name                  = "mpeg4",
2774
    .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
2775
    .type                  = AVMEDIA_TYPE_VIDEO,
2776
    .id                    = AV_CODEC_ID_MPEG4,
2777
    .priv_data_size        = sizeof(Mpeg4DecContext),
2778 2779 2780
    .init                  = decode_init,
    .close                 = ff_h263_decode_end,
    .decode                = ff_h263_decode_frame,
2781 2782 2783
    .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                             AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                             AV_CODEC_CAP_FRAME_THREADS,
2784
    .flush                 = ff_mpeg_flush,
2785
    .max_lowres            = 3,
2786
    .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
2787
    .profiles              = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles),
2788
    .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg4_update_thread_context),
2789
    .priv_class = &mpeg4_class,
2790 2791
};

2792

2793
#if CONFIG_MPEG4_VDPAU_DECODER && FF_API_VDPAU
2794 2795 2796 2797 2798 2799 2800
static const AVClass mpeg4_vdpau_class = {
    "MPEG4 Video VDPAU Decoder",
    av_default_item_name,
    mpeg4_options,
    LIBAVUTIL_VERSION_INT,
};

2801 2802
AVCodec ff_mpeg4_vdpau_decoder = {
    .name           = "mpeg4_vdpau",
2803
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
2804 2805
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_MPEG4,
2806
    .priv_data_size = sizeof(Mpeg4DecContext),
2807 2808 2809
    .init           = decode_init,
    .close          = ff_h263_decode_end,
    .decode         = ff_h263_decode_frame,
2810 2811
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                      AV_CODEC_CAP_HWACCEL_VDPAU,
2812
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_MPEG4,
2813 2814 2815 2816
                                                  AV_PIX_FMT_NONE },
    .priv_class     = &mpeg4_vdpau_class,
};
#endif