mpeg4videodec.c 106 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * MPEG4 decoder.
 * 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/opt.h"
26
#include "error_resilience.h"
27
#include "internal.h"
28
#include "mpegutils.h"
29 30 31
#include "mpegvideo.h"
#include "mpeg4video.h"
#include "h263.h"
32
#include "thread.h"
33

34 35 36 37
/* 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. */
38 39 40 41 42 43 44 45
#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;

46
static const int mb_type_b_map[4] = {
47
    MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
48 49 50
    MB_TYPE_L0L1    | MB_TYPE_16x16,
    MB_TYPE_L1      | MB_TYPE_16x16,
    MB_TYPE_L0      | MB_TYPE_16x16,
51 52 53
};

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

    /* find prediction */
65
    ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
66 67 68
    ac_val1 = ac_val;
    if (s->ac_pred) {
        if (dir == 0) {
69
            const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride;
70 71 72
            /* left prediction */
            ac_val -= 16;

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

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

    /* top copy */
105 106
    for (i = 1; i < 8; i++)
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i]];
107 108 109 110 111 112
}

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

119
    if (s->workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker)
120 121
        return 0;

122 123 124
    while (v <= 0xFF) {
        if (s->pict_type == AV_PICTURE_TYPE_B ||
            (v >> (8 - s->pict_type) != 1) || s->partitioned_frame)
125
            break;
126 127 128
        skip_bits(&s->gb, 8 + s->pict_type);
        bits_count += 8 + s->pict_type;
        v = show_bits(&s->gb, 16);
129 130
    }

131 132 133
    if (bits_count + 8 >= s->gb.size_in_bits) {
        v >>= 8;
        v  |= 0x7F >> (7 - (bits_count & 7));
134

135
        if (v == 0x7F)
136
            return s->mb_num;
137 138
    } else {
        if (v == ff_mpeg4_resync_prefix[bits_count & 7]) {
139
            int len, mb_num;
140
            int mb_num_bits = av_log2(s->mb_num - 1) + 1;
141
            GetBitContext gb = s->gb;
142 143 144 145

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

146 147 148
            for (len = 0; len < 32; len++)
                if (get_bits1(&s->gb))
                    break;
149

150 151
            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)
152 153
                mb_num= -1;

154
            s->gb = gb;
155

156
            if (len >= ff_mpeg4_get_video_packet_prefix_length(s))
157
                return mb_num;
158 159 160 161 162
        }
    }
    return 0;
}

163
static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
164
{
165
    MpegEncContext *s = &ctx->m;
166 167 168 169 170 171 172 173
    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;
174 175
    int sprite_ref[4][2];
    int virtual_ref[2][2];
176 177 178 179 180

    // 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 } };
181

182 183
    if (w <= 0 || h <= 0)
        return AVERROR_INVALIDDATA;
184

185
    for (i = 0; i < ctx->num_sprite_warping_points; i++) {
186
        int length;
187
        int x = 0, y = 0;
188

189 190 191
        length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
        if (length)
            x = get_xbits(gb, length);
192

193
        if (!(ctx->divx_version == 500 && ctx->divx_build == 413))
194 195 196 197 198 199 200
            skip_bits1(gb);     /* marker bit */

        length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
        if (length)
            y = get_xbits(gb, length);

        skip_bits1(gb);         /* marker bit */
201 202
        ctx->sprite_traj[i][0] = d[i][0] = x;
        ctx->sprite_traj[i][1] = d[i][1] = y;
203
    }
204
    for (; i < 4; i++)
205
        ctx->sprite_traj[i][0] = ctx->sprite_traj[i][1] = 0;
206 207 208 209 210 211 212 213 214

    while ((1 << alpha) < w)
        alpha++;
    while ((1 << beta) < h)
        beta++;  /* typo in the mpeg4 std for the definition of w' and h' */
    w2 = 1 << alpha;
    h2 = 1 << beta;

    // Note, the 4th point isn't used for GMC
215
    if (ctx->divx_version == 500 && ctx->divx_build == 413) {
216 217 218 219 220 221
        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];
222
    } else {
223 224 225 226 227 228
        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]);
229
    }
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
    /* 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]); */

    /* this is mostly identical to the mpeg4 std (and is totally unreadable
     * 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);

253
    switch (ctx->num_sprite_warping_points) {
254 255 256 257 258 259 260 261 262
    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;
263 264
        ctx->sprite_shift[0]   =
        ctx->sprite_shift[1]   = 0;
265 266 267 268 269 270 271 272 273 274 275 276
        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;
277 278
        ctx->sprite_shift[0]   =
        ctx->sprite_shift[1]   = 0;
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
        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]);

306 307
        ctx->sprite_shift[0]  = alpha + rho;
        ctx->sprite_shift[1]  = alpha + rho + 2;
308 309 310 311 312 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
        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;

342 343
        ctx->sprite_shift[0]  = alpha + beta + rho - min_ab;
        ctx->sprite_shift[1]  = alpha + beta + rho - min_ab + 2;
344
        break;
345 346
    }
    /* try to simplify the situation */
347
    if (s->sprite_delta[0][0] == a << ctx->sprite_shift[0] &&
348 349
        s->sprite_delta[0][1] == 0 &&
        s->sprite_delta[1][0] == 0 &&
350 351 352 353 354
        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];
355 356 357 358
        s->sprite_delta[0][0] = a;
        s->sprite_delta[0][1] = 0;
        s->sprite_delta[1][0] = 0;
        s->sprite_delta[1][1] = a;
359 360
        ctx->sprite_shift[0] = 0;
        ctx->sprite_shift[1] = 0;
361 362
        s->real_sprite_warping_points = 1;
    } else {
363 364
        int shift_y = 16 - ctx->sprite_shift[0];
        int shift_c = 16 - ctx->sprite_shift[1];
365 366 367 368 369
        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;
370
            ctx->sprite_shift[i]     = 16;
371
        }
372
        s->real_sprite_warping_points = ctx->num_sprite_warping_points;
373
    }
374

375
    return 0;
376 377
}

378 379
static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
    int len = FFMIN(ctx->time_increment_bits + 3, 15);
380 381 382 383 384 385 386 387 388

    get_bits(gb, len);
    if (get_bits1(gb))
        get_bits(gb, len);
    check_marker(gb, "after new_pred");

    return 0;
}

389
/**
390
 * Decode the next video packet.
391 392
 * @return <0 if something went wrong
 */
393
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
394
{
395 396
    MpegEncContext *s = &ctx->m;

397 398
    int mb_num_bits      = av_log2(s->mb_num - 1) + 1;
    int header_extension = 0, mb_num, len;
399 400

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

404 405 406
    for (len = 0; len < 32; len++)
        if (get_bits1(&s->gb))
            break;
407

408
    if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
409 410 411 412
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
        return -1;
    }

413
    if (ctx->shape != RECT_SHAPE) {
414 415
        header_extension = get_bits1(&s->gb);
        // FIXME more stuff here
416 417
    }

418 419 420 421
    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);
422 423 424
        return -1;
    }

425 426
    s->mb_x = mb_num % s->mb_width;
    s->mb_y = mb_num / s->mb_width;
427

428
    if (ctx->shape != BIN_ONLY_SHAPE) {
429 430 431
        int qscale = get_bits(&s->gb, s->quant_precision);
        if (qscale)
            s->chroma_qscale = s->qscale = qscale;
432 433
    }

434
    if (ctx->shape == RECT_SHAPE)
435 436 437 438
        header_extension = get_bits1(&s->gb);

    if (header_extension) {
        int time_incr = 0;
439 440 441 442 443

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

        check_marker(&s->gb, "before time_increment in video packed header");
444
        skip_bits(&s->gb, ctx->time_increment_bits);      /* time_increment */
445 446 447
        check_marker(&s->gb, "before vop_coding_type in video packed header");

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

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

460
            // FIXME reduced res stuff here
461

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

    return 0;
}

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

494
    if (s->workaround_bugs & FF_BUG_AMV)
495 496
        len >>= s->quarter_sample;

497
    if (s->real_sprite_warping_points == 1) {
498
        if (ctx->divx_version == 500 && ctx->divx_build == 413)
499 500 501 502 503 504
            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];
505
        shift = ctx->sprite_shift[0];
506 507
        if (n)
            dy -= 1 << (shift + a + 1);
508
        else
509 510 511 512 513
            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++) {
514 515
            int v;

516 517 518 519 520
            v = mb_v + dy * y;
            // FIXME optimize
            for (x = 0; x < 16; x++) {
                sum += v >> shift;
                v   += dx;
521 522
            }
        }
523
        sum = RSHIFT(sum, a + 8 - s->quarter_sample);
524 525
    }

526 527 528 529
    if (sum < -len)
        sum = -len;
    else if (sum >= len)
        sum = len - 1;
530 531 532 533 534

    return sum;
}

/**
535
 * Decode the dc value.
536 537 538 539
 * @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
 */
540
static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
541 542 543 544 545 546 547
{
    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);
548 549

    if (code < 0 || code > 9 /* && s->nbit < 9 */) {
550 551 552
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
        return -1;
    }
553

554 555 556
    if (code == 0) {
        level = 0;
    } else {
557 558 559 560 561 562
        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));
563
                else
564
                    level = -get_bits(&s->gb, code - 1) - (1 << (code - 1));
565
            }
566
        } else {
567 568 569
            level = get_xbits(&s->gb, code);
        }

570 571
        if (code > 8) {
            if (get_bits1(&s->gb) == 0) { /* marker */
572
                if (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
573 574 575 576 577 578 579 580 581 582 583
                    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);
}

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

    /* decode first partition */
594 595
    s->first_slice_line = 1;
    for (; s->mb_y < s->mb_height; s->mb_y++) {
596
        ff_init_block_index(s);
597 598
        for (; s->mb_x < s->mb_width; s->mb_x++) {
            const int xy = s->mb_x + s->mb_y * s->mb_stride;
599
            int cbpc;
600
            int dir = 0;
601 602 603

            mb_num++;
            ff_update_block_index(s);
604 605
            if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
                s->first_slice_line = 0;
606

607
            if (s->pict_type == AV_PICTURE_TYPE_I) {
608 609
                int i;

610 611 612
                do {
                    if (show_bits_long(&s->gb, 19) == DC_MARKER)
                        return mb_num - 1;
613

614
                    cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
615 616
                    if (cbpc < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
617
                               "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
618 619
                        return -1;
                    }
620
                } while (cbpc == 8);
621

622
                s->cbp_table[xy]               = cbpc & 3;
623
                s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
624
                s->mb_intra                    = 1;
625

626
                if (cbpc & 4)
627 628
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);

629 630 631 632
                s->current_picture.qscale_table[xy] = s->qscale;

                s->mbintra_table[xy] = 1;
                for (i = 0; i < 6; i++) {
633
                    int dc_pred_dir;
634 635 636 637
                    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);
638 639
                        return -1;
                    }
640 641 642
                    dir <<= 1;
                    if (dc_pred_dir)
                        dir |= 1;
643
                }
644 645
                s->pred_dir_table[xy] = dir;
            } else { /* P/S_TYPE */
646
                int mx, my, pred_x, pred_y, bits;
647 648
                int16_t *const mot_val = s->current_picture.motion_val[0][s->block_index[0]];
                const int stride       = s->b8_stride * 2;
649 650

try_again:
651 652 653 654
                bits = show_bits(&s->gb, 17);
                if (bits == MOTION_MARKER)
                    return mb_num - 1;

655
                skip_bits1(&s->gb);
656
                if (bits & 0x10000) {
657
                    /* skip mb */
658
                    if (s->pict_type == AV_PICTURE_TYPE_S &&
659
                        ctx->vol_sprite_usage == GMC_SPRITE) {
660 661 662 663
                        s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                         MB_TYPE_16x16 |
                                                         MB_TYPE_GMC   |
                                                         MB_TYPE_L0;
664 665
                        mx = get_amv(ctx, 0);
                        my = get_amv(ctx, 1);
666 667 668 669 670
                    } else {
                        s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                         MB_TYPE_16x16 |
                                                         MB_TYPE_L0;
                        mx = my = 0;
671
                    }
672 673 674 675 676 677 678 679 680 681
                    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])
682 683 684 685
                        ff_clean_intra_table_entries(s);
                    continue;
                }

686
                cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
687 688
                if (cbpc < 0) {
                    av_log(s->avctx, AV_LOG_ERROR,
689
                           "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
690 691
                    return -1;
                }
692
                if (cbpc == 20)
693 694
                    goto try_again;

695
                s->cbp_table[xy] = cbpc & (8 + 3);  // 8 is dquant
696 697 698

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

699
                if (s->mb_intra) {
700
                    s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
701 702 703 704 705 706 707 708 709 710 711
                    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])
712 713
                        ff_clean_intra_table_entries(s);

714
                    if (s->pict_type == AV_PICTURE_TYPE_S &&
715
                        ctx->vol_sprite_usage == GMC_SPRITE &&
716 717 718 719
                        (cbpc & 16) == 0)
                        s->mcsel = get_bits1(&s->gb);
                    else
                        s->mcsel = 0;
720 721 722 723

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

724
                        ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
725
                        if (!s->mcsel) {
726
                            mx = ff_h263_decode_motion(s, pred_x, s->f_code);
727 728 729
                            if (mx >= 0xffff)
                                return -1;

730
                            my = ff_h263_decode_motion(s, pred_y, s->f_code);
731 732
                            if (my >= 0xffff)
                                return -1;
733 734
                            s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
                                                             MB_TYPE_L0;
735
                        } else {
736 737
                            mx = get_amv(ctx, 0);
                            my = get_amv(ctx, 1);
738 739 740
                            s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
                                                             MB_TYPE_GMC   |
                                                             MB_TYPE_L0;
741 742
                        }

743 744 745 746 747 748 749 750
                        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;
751 752
                    } else {
                        int i;
753 754 755 756
                        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);
757
                            mx = ff_h263_decode_motion(s, pred_x, s->f_code);
758 759 760
                            if (mx >= 0xffff)
                                return -1;

761
                            my = ff_h263_decode_motion(s, pred_y, s->f_code);
762 763 764 765 766 767 768 769 770
                            if (my >= 0xffff)
                                return -1;
                            mot_val[0] = mx;
                            mot_val[1] = my;
                        }
                    }
                }
            }
        }
771
        s->mb_x = 0;
772 773 774 775 776 777 778 779 780
    }

    return mb_num;
}

/**
 * decode second partition.
 * @return <0 if an error occurred
 */
781 782 783
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
{
    int mb_num = 0;
784 785
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };

786 787 788
    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++) {
789
        ff_init_block_index(s);
790 791
        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;
792 793 794

            mb_num++;
            ff_update_block_index(s);
795 796 797 798 799 800 801 802 803
            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);
804 805 806
                    return -1;
                }

807 808 809
                s->cbp_table[xy]               |= cbpy << 2;
                s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
            } else { /* P || S_TYPE */
810
                if (IS_INTRA(s->current_picture.mb_type[xy])) {
811 812
                    int i;
                    int dir     = 0;
813
                    int ac_pred = get_bits1(&s->gb);
814
                    int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
815

816 817 818
                    if (cbpy < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
819 820 821
                        return -1;
                    }

822
                    if (s->cbp_table[xy] & 8)
823
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
824
                    s->current_picture.qscale_table[xy] = s->qscale;
825

826
                    for (i = 0; i < 6; i++) {
827
                        int dc_pred_dir;
828 829 830 831
                        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);
832 833
                            return -1;
                        }
834 835 836
                        dir <<= 1;
                        if (dc_pred_dir)
                            dir |= 1;
837
                    }
838 839 840 841
                    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;
842 843
                } else if (IS_SKIP(s->current_picture.mb_type[xy])) {
                    s->current_picture.qscale_table[xy] = s->qscale;
844 845
                    s->cbp_table[xy]                    = 0;
                } else {
846
                    int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
847

848 849 850
                    if (cbpy < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
851 852 853
                        return -1;
                    }

854
                    if (s->cbp_table[xy] & 8)
855
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
856
                    s->current_picture.qscale_table[xy] = s->qscale;
857

858 859
                    s->cbp_table[xy] &= 3;  // remove dquant
                    s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
860 861 862
                }
            }
        }
863 864 865
        if (mb_num >= mb_count)
            return 0;
        s->mb_x = 0;
866 867 868 869 870
    }
    return 0;
}

/**
871
 * Decode the first and second partition.
872 873
 * @return <0 if error (and sets error type in the error_status_table)
 */
874
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
875
{
876
    MpegEncContext *s = &ctx->m;
877
    int mb_num;
878 879
    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;
880

881
    mb_num = mpeg4_decode_partition_a(ctx);
882 883 884
    if (mb_num < 0) {
        ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                        s->mb_x, s->mb_y, part_a_error);
885 886 887
        return -1;
    }

888
    if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) {
889
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
890 891
        ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                        s->mb_x, s->mb_y, part_a_error);
892 893 894
        return -1;
    }

895
    s->mb_num_left = mb_num;
896

897 898
    if (s->pict_type == AV_PICTURE_TYPE_I) {
        while (show_bits(&s->gb, 9) == 1)
899
            skip_bits(&s->gb, 9);
900 901 902 903
        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);
904 905
            return -1;
        }
906 907
    } else {
        while (show_bits(&s->gb, 10) == 1)
908
            skip_bits(&s->gb, 10);
909 910 911 912
        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);
913 914 915
            return -1;
        }
    }
916 917
    ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                    s->mb_x - 1, s->mb_y, part_a_end);
918

919 920 921 922
    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);
923
        return -1;
924 925 926 927
    } 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);
928 929 930 931 932 933
    }

    return 0;
}

/**
934
 * Decode a block.
935 936
 * @return <0 if an error occurred
 */
937
static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
938
                                     int n, int coded, int intra, int rvlc)
939
{
940
    MpegEncContext *s = &ctx->m;
941
    int level, i, last, run, qmul, qadd;
942
    int av_uninit(dc_pred_dir);
943 944 945 946 947 948 949
    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) {
950
        if (ctx->use_intra_dc_vlc) {
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
            /* 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 {
967 968
            i = -1;
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
        }
        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 {
986
            scan_table = s->intra_scantable.permutated;
987 988 989
        }
        qmul = 1;
        qadd = 0;
990 991 992 993 994 995
    } else {
        i = -1;
        if (!coded) {
            s->block_last_index[n] = i;
            return 0;
        }
996 997 998 999
        if (rvlc)
            rl = &ff_rvlc_rl_inter;
        else
            rl = &ff_h263_rl_inter;
1000 1001 1002

        scan_table = s->intra_scantable.permutated;

1003 1004 1005 1006
        if (s->mpeg_quant) {
            qmul = 1;
            qadd = 0;
            if (rvlc)
1007
                rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
1008
            else
1009
                rl_vlc = ff_h263_rl_inter.rl_vlc[0];
1010
        } else {
1011 1012
            qmul = s->qscale << 1;
            qadd = (s->qscale - 1) | 1;
1013
            if (rvlc)
1014
                rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
1015
            else
1016
                rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
1017 1018
        }
    }
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
    {
        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);
1033

1034 1035 1036 1037
                    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);
1038 1039
                    UPDATE_CACHE(re, &s->gb);

1040 1041 1042 1043 1044 1045
                    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);
1046

1047 1048
                    level = SHOW_UBITS(re, &s->gb, 11);
                    SKIP_CACHE(re, &s->gb, 11);
1049

1050 1051 1052
                    if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
                        av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
                        return -1;
1053
                    }
1054
                    SKIP_CACHE(re, &s->gb, 5);
1055

1056 1057 1058
                    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);
1059

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
                    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");
1087 1088
                                    if (!(s->err_recognition & AV_EF_IGNORE_ERR))
                                        return -1;
1089 1090
                                }
                                SKIP_CACHE(re, &s->gb, 1);
1091

1092 1093
                                level = SHOW_SBITS(re, &s->gb, 12);
                                SKIP_CACHE(re, &s->gb, 12);
1094

1095 1096 1097
                                if (SHOW_UBITS(re, &s->gb, 1) == 0) {
                                    av_log(s->avctx, AV_LOG_ERROR,
                                           "2. marker bit missing in 3. esc\n");
1098 1099
                                    if (!(s->err_recognition & AV_EF_IGNORE_ERR))
                                        return -1;
1100
                                }
1101

1102
                                SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
1103 1104 1105
                            }

#if 0
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
                            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;
                                        }
                                    }
1124 1125 1126
                                }
                            }
#endif
1127 1128 1129 1130 1131 1132
                            if (level > 0)
                                level = level * qmul + qadd;
                            else
                                level = level * qmul - qadd;

                            if ((unsigned)(level + 2048) > 4095) {
1133
                                if (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) {
1134 1135 1136 1137 1138 1139 1140 1141
                                    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;
1142
                            }
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153

                            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);
1154
                        }
1155 1156 1157 1158 1159 1160 1161 1162
                    } 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);
1163 1164 1165
                    }
                }
            } else {
1166
                i    += run;
1167 1168 1169
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                LAST_SKIP_BITS(re, &s->gb, 1);
            }
1170
            tprintf(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
            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;
1181 1182 1183 1184
            }

            block[scan_table[i]] = level;
        }
1185
        CLOSE_READER(re, &s->gb);
1186
    }
1187 1188

not_coded:
1189
    if (intra) {
1190
        if (!ctx->use_intra_dc_vlc) {
1191 1192
            block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);

1193
            i -= i >> 31;  // if (i == -1) i = 0;
1194 1195
        }

1196
        ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1197 1198
        if (s->ac_pred)
            i = 63;  // FIXME not optimal
1199 1200 1201 1202 1203 1204 1205 1206 1207
    }
    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
1208
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
1209
{
1210
    Mpeg4DecContext *ctx = (Mpeg4DecContext *)s;
1211
    int cbp, mb_type;
1212
    const int xy = s->mb_x + s->mb_y * s->mb_stride;
1213

1214
    mb_type = s->current_picture.mb_type[xy];
1215
    cbp     = s->cbp_table[xy];
1216

1217
    ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1218

1219
    if (s->current_picture.qscale_table[xy] != s->qscale)
1220
        ff_set_qscale(s, s->current_picture.qscale_table[xy]);
1221

1222 1223
    if (s->pict_type == AV_PICTURE_TYPE_P ||
        s->pict_type == AV_PICTURE_TYPE_S) {
1224
        int i;
1225
        for (i = 0; i < 4; i++) {
1226 1227
            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];
1228 1229 1230 1231 1232
        }
        s->mb_intra = IS_INTRA(mb_type);

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

            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;
1259
        s->ac_pred  = IS_ACPRED(s->current_picture.mb_type[xy]);
1260 1261 1262 1263 1264 1265 1266
    }

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

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

1293
static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
1294
{
1295
    Mpeg4DecContext *ctx = (Mpeg4DecContext *)s;
1296 1297 1298
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
    int16_t *mot_val;
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
1299
    const int xy = s->mb_x + s->mb_y * s->mb_stride;
1300

1301
    av_assert2(s->h263_pred);
1302

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

        s->dsp.clear_blocks(s->block[0]);
1343
        dquant      = cbpc & 8;
1344
        s->mb_intra = ((cbpc & 4) != 0);
1345 1346
        if (s->mb_intra)
            goto intra;
1347

1348
        if (s->pict_type == AV_PICTURE_TYPE_S &&
1349
            ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
1350 1351 1352
            s->mcsel = get_bits1(&s->gb);
        else
            s->mcsel = 0;
1353
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
1354 1355

        cbp = (cbpc & 3) | (cbpy << 2);
1356
        if (dquant)
1357
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1358 1359 1360
        if ((!s->progressive_sequence) &&
            (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE)))
            s->interlaced_dct = get_bits1(&s->gb);
1361 1362 1363

        s->mv_dir = MV_DIR_FORWARD;
        if ((cbpc & 16) == 0) {
1364 1365 1366 1367
            if (s->mcsel) {
                s->current_picture.mb_type[xy] = MB_TYPE_GMC   |
                                                 MB_TYPE_16x16 |
                                                 MB_TYPE_L0;
1368
                /* 16x16 global motion prediction */
1369
                s->mv_type     = MV_TYPE_16X16;
1370 1371
                mx             = get_amv(ctx, 0);
                my             = get_amv(ctx, 1);
1372 1373
                s->mv[0][0][0] = mx;
                s->mv[0][0][1] = my;
1374 1375 1376 1377
            } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
                s->current_picture.mb_type[xy] = MB_TYPE_16x8 |
                                                 MB_TYPE_L0   |
                                                 MB_TYPE_INTERLACED;
1378
                /* 16x8 field motion prediction */
1379
                s->mv_type = MV_TYPE_FIELD;
1380

1381 1382
                s->field_select[0][0] = get_bits1(&s->gb);
                s->field_select[0][1] = get_bits1(&s->gb);
1383

1384
                ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1385

1386
                for (i = 0; i < 2; i++) {
1387
                    mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1388 1389 1390
                    if (mx >= 0xffff)
                        return -1;

1391
                    my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
1392 1393 1394 1395 1396 1397
                    if (my >= 0xffff)
                        return -1;

                    s->mv[0][i][0] = mx;
                    s->mv[0][i][1] = my;
                }
1398
            } else {
1399
                s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
1400 1401
                /* 16x16 motion prediction */
                s->mv_type = MV_TYPE_16X16;
1402 1403
                ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
                mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1404 1405 1406 1407

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

1408
                my = ff_h263_decode_motion(s, pred_y, s->f_code);
1409 1410 1411 1412 1413 1414 1415

                if (my >= 0xffff)
                    return -1;
                s->mv[0][0][0] = mx;
                s->mv[0][0][1] = my;
            }
        } else {
1416
            s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
1417 1418
            s->mv_type                     = MV_TYPE_8X8;
            for (i = 0; i < 4; i++) {
1419
                mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1420
                mx      = ff_h263_decode_motion(s, pred_x, s->f_code);
1421 1422 1423
                if (mx >= 0xffff)
                    return -1;

1424
                my = ff_h263_decode_motion(s, pred_y, s->f_code);
1425 1426 1427 1428
                if (my >= 0xffff)
                    return -1;
                s->mv[0][i][0] = mx;
                s->mv[0][i][1] = my;
1429 1430
                mot_val[0]     = mx;
                mot_val[1]     = my;
1431 1432
            }
        }
1433 1434 1435
    } else if (s->pict_type == AV_PICTURE_TYPE_B) {
        int modb1;   // first bit of modb
        int modb2;   // second bit of modb
1436 1437
        int mb_type;

1438 1439
        s->mb_intra = 0;  // B-frames never contain intra blocks
        s->mcsel    = 0;  //      ...               true gmc blocks
1440

1441 1442 1443 1444 1445 1446
        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;
1447
            }
1448

1449
            ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);
1450 1451 1452
        }

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

1455 1456 1457
        if (s->mb_skipped) {
            /* skip mb */
            for (i = 0; i < 6; i++)
1458 1459
                s->block_last_index[i] = -1;

1460 1461 1462 1463 1464
            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] =
1465
            s->mv[1][0][1] = 0;
1466 1467 1468
            s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                             MB_TYPE_16x16 |
                                             MB_TYPE_L0;
1469 1470 1471
            goto end;
        }

1472 1473 1474 1475 1476 1477 1478 1479 1480
        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) {
1481 1482 1483
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
                return -1;
            }
1484 1485 1486 1487
            mb_type = mb_type_b_map[mb_type];
            if (modb2) {
                cbp = 0;
            } else {
1488
                s->dsp.clear_blocks(s->block[0]);
1489
                cbp = get_bits(&s->gb, 6);
1490 1491 1492
            }

            if ((!IS_DIRECT(mb_type)) && cbp) {
1493 1494
                if (get_bits1(&s->gb))
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2);
1495 1496
            }

1497 1498 1499
            if (!s->progressive_sequence) {
                if (cbp)
                    s->interlaced_dct = get_bits1(&s->gb);
1500

1501
                if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) {
1502 1503 1504
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
                    mb_type &= ~MB_TYPE_16x16;

1505 1506 1507
                    if (USES_LIST(mb_type, 0)) {
                        s->field_select[0][0] = get_bits1(&s->gb);
                        s->field_select[0][1] = get_bits1(&s->gb);
1508
                    }
1509 1510 1511
                    if (USES_LIST(mb_type, 1)) {
                        s->field_select[1][0] = get_bits1(&s->gb);
                        s->field_select[1][1] = get_bits1(&s->gb);
1512 1513 1514 1515 1516
                    }
                }
            }

            s->mv_dir = 0;
1517 1518
            if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) {
                s->mv_type = MV_TYPE_16X16;
1519

1520
                if (USES_LIST(mb_type, 0)) {
1521 1522
                    s->mv_dir = MV_DIR_FORWARD;

1523 1524
                    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);
1525 1526 1527 1528 1529 1530
                    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;
1531 1532
                }

1533
                if (USES_LIST(mb_type, 1)) {
1534 1535
                    s->mv_dir |= MV_DIR_BACKWARD;

1536 1537
                    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);
1538 1539 1540 1541 1542 1543
                    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;
1544
                }
1545 1546
            } else if (!IS_DIRECT(mb_type)) {
                s->mv_type = MV_TYPE_FIELD;
1547

1548
                if (USES_LIST(mb_type, 0)) {
1549 1550
                    s->mv_dir = MV_DIR_FORWARD;

1551 1552 1553 1554 1555 1556
                    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;
1557 1558 1559
                    }
                }

1560
                if (USES_LIST(mb_type, 1)) {
1561 1562
                    s->mv_dir |= MV_DIR_BACKWARD;

1563 1564 1565 1566 1567 1568
                    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;
1569 1570 1571 1572 1573
                    }
                }
            }
        }

1574 1575 1576 1577 1578
        if (IS_DIRECT(mb_type)) {
            if (IS_SKIP(mb_type)) {
                mx =
                my = 0;
            } else {
1579 1580
                mx = ff_h263_decode_motion(s, 0, 1);
                my = ff_h263_decode_motion(s, 0, 1);
1581 1582 1583
            }

            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1584
            mb_type  |= ff_mpeg4_set_direct_mv(s, mx, my);
1585
        }
1586
        s->current_picture.mb_type[xy] = mb_type;
1587
    } else { /* I-Frame */
1588
        do {
1589
            cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1590 1591 1592
            if (cbpc < 0) {
                av_log(s->avctx, AV_LOG_ERROR,
                       "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1593 1594
                return -1;
            }
1595
        } while (cbpc == 8);
1596 1597 1598

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

1600 1601
intra:
        s->ac_pred = get_bits1(&s->gb);
1602
        if (s->ac_pred)
1603
            s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1604
        else
1605
            s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1606

1607
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1608 1609 1610
        if (cbpy < 0) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1611 1612 1613 1614
            return -1;
        }
        cbp = (cbpc & 3) | (cbpy << 2);

1615
        ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1616

1617
        if (dquant)
1618 1619
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);

1620 1621
        if (!s->progressive_sequence)
            s->interlaced_dct = get_bits1(&s->gb);
1622 1623 1624 1625

        s->dsp.clear_blocks(s->block[0]);
        /* decode each block */
        for (i = 0; i < 6; i++) {
1626
            if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 1, 0) < 0)
1627
                return -1;
1628
            cbp += cbp;
1629 1630 1631 1632 1633 1634
        }
        goto end;
    }

    /* decode each block */
    for (i = 0; i < 6; i++) {
1635
        if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 0, 0) < 0)
1636
            return -1;
1637
        cbp += cbp;
1638 1639
    }

1640 1641 1642
end:
    /* per-MB end of slice check */
    if (s->codec_id == AV_CODEC_ID_MPEG4) {
1643
        int next = mpeg4_is_resync(ctx);
1644
        if (next) {
1645
            if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
1646 1647 1648
                return -1;
            } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
                return SLICE_END;
1649

1650
            if (s->pict_type == AV_PICTURE_TYPE_B) {
1651
                const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1652
                ff_thread_await_progress(&s->next_picture_ptr->tf,
1653 1654 1655
                                         (s->mb_x + delta >= s->mb_width)
                                         ? FFMIN(s->mb_y + 1, s->mb_height - 1)
                                         : s->mb_y, 0);
1656
                if (s->next_picture.mbskip_table[xy + delta])
1657 1658 1659 1660
                    return SLICE_OK;
            }

            return SLICE_END;
1661 1662 1663 1664 1665 1666
        }
    }

    return SLICE_OK;
}

1667 1668
static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
{
1669 1670
    int hours, minutes, seconds;

1671
    if (!show_bits(gb, 23)) {
1672 1673 1674 1675
        av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
        return -1;
    }

1676 1677
    hours   = get_bits(gb, 5);
    minutes = get_bits(gb, 6);
1678
    skip_bits1(gb);
1679
    seconds = get_bits(gb, 6);
1680

1681
    s->time_base = seconds + 60*(minutes + 60*hours);
1682 1683 1684 1685 1686 1687 1688

    skip_bits1(gb);
    skip_bits1(gb);

    return 0;
}

1689 1690
static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb)
{
1691

1692 1693
    s->avctx->profile = get_bits(gb, 4);
    s->avctx->level   = get_bits(gb, 4);
1694

1695 1696 1697 1698
    // for Simple profile, level 0
    if (s->avctx->profile == 0 && s->avctx->level == 8) {
        s->avctx->level = 0;
    }
1699

1700
    return 0;
1701 1702
}

1703
static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
1704
{
1705
    MpegEncContext *s = &ctx->m;
1706 1707 1708
    int width, height, vo_ver_id;

    /* vol header */
1709 1710 1711 1712 1713
    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 */
1714 1715 1716
    } else {
        vo_ver_id = 1;
    }
1717 1718 1719 1720 1721 1722
    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];
1723 1724
    }

1725 1726 1727
    if ((s->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
        int chroma_format = get_bits(gb, 2);
        if (chroma_format != CHROMA_420)
1728
            av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
1729 1730 1731

        s->low_delay = get_bits1(gb);
        if (get_bits1(gb)) {    /* vbv parameters */
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
            get_bits(gb, 15);   /* first_half_bitrate */
            skip_bits1(gb);     /* marker */
            get_bits(gb, 15);   /* latter_half_bitrate */
            skip_bits1(gb);     /* marker */
            get_bits(gb, 15);   /* first_half_vbv_buffer_size */
            skip_bits1(gb);     /* marker */
            get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
            get_bits(gb, 11);   /* first_half_vbv_occupancy */
            skip_bits1(gb);     /* marker */
            get_bits(gb, 15);   /* latter_half_vbv_occupancy */
            skip_bits1(gb);     /* marker */
        }
1744 1745
    } else {
        /* is setting low delay flag only once the smartest thing to do?
1746
         * low delay detection won't be overridden. */
1747 1748
        if (s->picture_number == 0)
            s->low_delay = 0;
1749 1750
    }

1751 1752
    ctx->shape = get_bits(gb, 2); /* vol shape */
    if (ctx->shape != RECT_SHAPE)
1753
        av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
1754
    if (ctx->shape == GRAY_SHAPE && vo_ver_id != 1) {
1755
        av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
1756
        skip_bits(gb, 4);  /* video_object_layer_shape_extension */
1757 1758 1759 1760 1761
    }

    check_marker(gb, "before time_increment_resolution");

    s->avctx->time_base.den = get_bits(gb, 16);
1762
    if (!s->avctx->time_base.den) {
1763
        av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
1764
        s->avctx->time_base.num = 0;
1765 1766 1767
        return -1;
    }

1768 1769 1770
    ctx->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
    if (ctx->time_increment_bits < 1)
        ctx->time_increment_bits = 1;
1771 1772 1773

    check_marker(gb, "before fixed_vop_rate");

1774
    if (get_bits1(gb) != 0)     /* fixed_vop_rate  */
1775
        s->avctx->time_base.num = get_bits(gb, ctx->time_increment_bits);
1776
    else
1777 1778
        s->avctx->time_base.num = 1;

1779
    ctx->t_frame = 0;
1780

1781 1782
    if (ctx->shape != BIN_ONLY_SHAPE) {
        if (ctx->shape == RECT_SHAPE) {
1783
            check_marker(gb, "before width");
1784
            width = get_bits(gb, 13);
1785
            check_marker(gb, "before height");
1786
            height = get_bits(gb, 13);
1787
            check_marker(gb, "after height");
1788 1789
            if (width && height &&  /* they should be non zero but who knows */
                !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
1790 1791 1792
                if (s->width && s->height &&
                    (s->width != width || s->height != height))
                    s->context_reinit = 1;
1793
                s->width  = width;
1794 1795 1796 1797
                s->height = height;
            }
        }

1798 1799 1800 1801 1802 1803 1804
        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 */
                   "MPEG4 OBMC not supported (very likely buggy encoder)\n");
        if (vo_ver_id == 1)
1805
            ctx->vol_sprite_usage = get_bits1(gb);    /* vol_sprite_usage */
1806
        else
1807
            ctx->vol_sprite_usage = get_bits(gb, 2);  /* vol_sprite_usage */
1808

1809
        if (ctx->vol_sprite_usage == STATIC_SPRITE)
1810
            av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
1811 1812 1813
        if (ctx->vol_sprite_usage == STATIC_SPRITE ||
            ctx->vol_sprite_usage == GMC_SPRITE) {
            if (ctx->vol_sprite_usage == STATIC_SPRITE) {
1814
                skip_bits(gb, 13); // sprite_width
1815
                skip_bits1(gb); /* marker */
1816
                skip_bits(gb, 13); // sprite_height
1817
                skip_bits1(gb); /* marker */
1818
                skip_bits(gb, 13); // sprite_left
1819
                skip_bits1(gb); /* marker */
1820
                skip_bits(gb, 13); // sprite_top
1821 1822
                skip_bits1(gb); /* marker */
            }
1823 1824
            ctx->num_sprite_warping_points = get_bits(gb, 6);
            if (ctx->num_sprite_warping_points > 3) {
1825 1826
                av_log(s->avctx, AV_LOG_ERROR,
                       "%d sprite_warping_points\n",
1827 1828
                       ctx->num_sprite_warping_points);
                ctx->num_sprite_warping_points = 0;
1829 1830
                return -1;
            }
1831
            s->sprite_warping_accuracy  = get_bits(gb, 2);
1832
            ctx->sprite_brightness_change = get_bits1(gb);
1833
            if (ctx->vol_sprite_usage == STATIC_SPRITE)
1834
                skip_bits1(gb); // low_latency_sprite
1835 1836 1837
        }
        // FIXME sadct disable bit if verid!=1 && shape not rect

1838 1839 1840 1841 1842 1843 1844
        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);
1845
            if (s->quant_precision<3 || s->quant_precision>9) {
1846 1847
                s->quant_precision = 5;
            }
1848 1849 1850 1851 1852 1853
        } else {
            s->quant_precision = 5;
        }

        // FIXME a bunch of grayscale shape things

1854
        if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
1855 1856 1857
            int i, v;

            /* load default matrixes */
1858 1859 1860 1861 1862 1863 1864 1865 1866
            for (i = 0; i < 64; i++) {
                int j = s->dsp.idct_permutation[i];
                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;
1867 1868 1869
            }

            /* load custom intra matrix */
1870 1871 1872
            if (get_bits1(gb)) {
                int last = 0;
                for (i = 0; i < 64; i++) {
1873
                    int j;
1874 1875 1876 1877 1878 1879 1880 1881
                    v = get_bits(gb, 8);
                    if (v == 0)
                        break;

                    last = v;
                    j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
                    s->intra_matrix[j]        = last;
                    s->chroma_intra_matrix[j] = last;
1882 1883 1884
                }

                /* replicate last value */
1885 1886 1887 1888
                for (; i < 64; i++) {
                    int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
                    s->intra_matrix[j]        = last;
                    s->chroma_intra_matrix[j] = last;
1889 1890 1891 1892
                }
            }

            /* load custom non intra matrix */
1893 1894 1895
            if (get_bits1(gb)) {
                int last = 0;
                for (i = 0; i < 64; i++) {
1896
                    int j;
1897 1898 1899 1900 1901 1902 1903 1904
                    v = get_bits(gb, 8);
                    if (v == 0)
                        break;

                    last = v;
                    j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
                    s->inter_matrix[j]        = v;
                    s->chroma_inter_matrix[j] = v;
1905 1906 1907
                }

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

            // FIXME a bunch of grayscale shape things
        }

1918 1919 1920 1921 1922
        if (vo_ver_id != 1)
            s->quarter_sample = get_bits1(gb);
        else
            s->quarter_sample = 0;

1923 1924 1925 1926 1927
        if (get_bits_left(gb) < 4) {
            av_log(s->avctx, AV_LOG_ERROR, "VOL Header truncated\n");
            return AVERROR_INVALIDDATA;
        }

1928 1929 1930 1931 1932
        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)) {
1933 1934 1935 1936 1937 1938
                    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 */
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* upampling */
1939
                }
1940
                if (!get_bits1(gb)) {
1941 1942 1943 1944
                    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 */
1945
                }
1946
                if (!check_marker(gb, "in complexity estimation part 1")) {
1947 1948 1949
                    skip_bits_long(gb, pos - get_bits_count(gb));
                    goto no_cplx_est;
                }
1950
                if (!get_bits1(gb)) {
1951 1952 1953 1954
                    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 */
1955
                }
1956
                if (!get_bits1(gb)) {
1957 1958 1959 1960 1961 1962
                    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 */
1963
                }
1964
                if (!check_marker(gb, "in complexity estimation part 2")) {
1965 1966 1967
                    skip_bits_long(gb, pos - get_bits_count(gb));
                    goto no_cplx_est;
                }
1968
                if (estimation_method == 1) {
1969 1970
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* sadct */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* qpel */
1971
                }
1972 1973 1974 1975 1976 1977
            } else
                av_log(s->avctx, AV_LOG_ERROR,
                       "Invalid Complexity estimation method %d\n",
                       estimation_method);
        } else {

1978
no_cplx_est:
1979 1980 1981
            ctx->cplx_estimation_trash_i =
            ctx->cplx_estimation_trash_p =
            ctx->cplx_estimation_trash_b = 0;
1982 1983
        }

1984
        ctx->resync_marker = !get_bits1(gb); /* resync_marker_disabled */
1985

1986 1987
        s->data_partitioning = get_bits1(gb);
        if (s->data_partitioning)
1988
            ctx->rvlc = get_bits1(gb);
1989

1990
        if (vo_ver_id != 1) {
1991 1992
            ctx->new_pred = get_bits1(gb);
            if (ctx->new_pred) {
1993 1994
                av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
                skip_bits(gb, 2); /* requested upstream message type */
1995
                skip_bits1(gb);   /* newpred segment type */
1996
            }
1997
            if (get_bits1(gb)) // reduced_res_vop
1998 1999 2000
                av_log(s->avctx, AV_LOG_ERROR,
                       "reduced resolution VOP not supported\n");
        } else {
2001
            ctx->new_pred = 0;
2002 2003
        }

2004
        ctx->scalability = get_bits1(gb);
2005

2006
        if (ctx->scalability) {
2007
            GetBitContext bak = *gb;
2008 2009 2010 2011 2012
            int h_sampling_factor_n;
            int h_sampling_factor_m;
            int v_sampling_factor_n;
            int v_sampling_factor_m;

2013
            skip_bits1(gb);    // hierarchy_type
Mans Rullgard's avatar
Mans Rullgard committed
2014 2015
            skip_bits(gb, 4);  /* ref_layer_id */
            skip_bits1(gb);    /* ref_layer_sampling_dir */
2016 2017 2018 2019
            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);
2020
            ctx->enhancement_type = get_bits1(gb);
2021 2022 2023

            if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
                v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2024 2025
                /* illegal scalability header (VERY broken encoder),
                 * trying to workaround */
2026
                ctx->scalability = 0;
2027 2028
                *gb            = bak;
            } else
2029 2030 2031 2032 2033
                av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");

            // bin shape stuff FIXME
        }
    }
2034

2035
    if (s->avctx->debug&FF_DEBUG_PICT_INFO) {
2036
        av_log(s->avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d,  %s%s%s%s\n",
2037
               s->avctx->time_base.num, s->avctx->time_base.den,
2038
               ctx->time_increment_bits,
2039 2040
               s->quant_precision,
               s->progressive_sequence,
2041
               ctx->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "",
2042
               s->data_partitioning ? "partition " : "", ctx->rvlc ? "rvlc " : ""
2043 2044 2045
        );
    }

2046 2047 2048 2049
    return 0;
}

/**
2050
 * Decode the user data stuff in the header.
2051 2052
 * Also initializes divx/xvid/lavc_version/build.
 */
2053
static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
2054
{
2055
    MpegEncContext *s = &ctx->m;
2056 2057 2058 2059 2060 2061
    char buf[256];
    int i;
    int e;
    int ver = 0, build = 0, ver2 = 0, ver3 = 0;
    char last;

2062 2063 2064 2065
    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);
2066
    }
2067
    buf[i] = 0;
2068 2069

    /* divx detection */
2070 2071 2072 2073
    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) {
2074 2075
        ctx->divx_version = ver;
        ctx->divx_build   = build;
2076
        s->divx_packed  = e == 3 && last == 'p';
2077
        if (s->divx_packed && !ctx->showed_packed_warning) {
2078
            av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and "
2079 2080
                   "wasteful way to store B-frames ('packed B-frames'). "
                   "Consider using a tool like VirtualDub or avidemux to fix it.\n");
2081
            ctx->showed_packed_warning = 1;
2082 2083 2084
        }
    }

2085
    /* libavcodec detection */
2086 2087 2088 2089 2090 2091 2092
    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;
2093
    }
2094 2095
    if (e != 4) {
        if (strcmp(buf, "ffmpeg") == 0)
2096
            ctx->lavc_build = 4600;
2097
    }
2098
    if (e == 4)
2099
        ctx->lavc_build = build;
2100 2101

    /* Xvid detection */
2102 2103
    e = sscanf(buf, "XviD%d", &build);
    if (e == 1)
2104
        ctx->xvid_build = build;
2105 2106 2107 2108

    return 0;
}

2109 2110 2111 2112 2113
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
{
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext *s = &ctx->m;

2114
    if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
2115 2116 2117 2118 2119 2120
        if (s->stream_codec_tag == AV_RL32("XVID") ||
            s->codec_tag        == AV_RL32("XVID") ||
            s->codec_tag        == AV_RL32("XVIX") ||
            s->codec_tag        == AV_RL32("RMP4") ||
            s->codec_tag        == AV_RL32("ZMP4") ||
            s->codec_tag        == AV_RL32("SIPP"))
2121
            ctx->xvid_build = 0;
2122 2123
    }

2124
    if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
2125 2126
        if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
            s->vol_control_parameters == 0)
2127
            ctx->divx_version = 400;  // divx 4
2128

2129 2130 2131
    if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
        ctx->divx_version =
        ctx->divx_build   = -1;
2132 2133 2134 2135 2136 2137 2138 2139 2140
    }

    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;

2141
        if (ctx->divx_version >= 500 && ctx->divx_build < 1814)
2142 2143
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA;

2144
        if (ctx->divx_version > 502 && ctx->divx_build < 1814)
2145 2146
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA2;

2147
        if (ctx->xvid_build <= 3U)
2148 2149
            s->padding_bug_score = 256 * 256 * 256 * 64;

2150
        if (ctx->xvid_build <= 1U)
2151 2152
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA;

2153
        if (ctx->xvid_build <= 12U)
2154 2155
            s->workaround_bugs |= FF_BUG_EDGE;

2156
        if (ctx->xvid_build <= 32U)
2157 2158 2159 2160 2161 2162 2163
            s->workaround_bugs |= FF_BUG_DC_CLIP;

#define SET_QPEL_FUNC(postfix1, postfix2)                           \
    s->dsp.put_        ## postfix1 = ff_put_        ## postfix2;    \
    s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;    \
    s->dsp.avg_        ## postfix1 = ff_avg_        ## postfix2;

2164
        if (ctx->lavc_build < 4653U)
2165 2166
            s->workaround_bugs |= FF_BUG_STD_QPEL;

2167
        if (ctx->lavc_build < 4655U)
2168 2169
            s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;

2170
        if (ctx->lavc_build < 4670U)
2171 2172
            s->workaround_bugs |= FF_BUG_EDGE;

2173
        if (ctx->lavc_build <= 4712U)
2174 2175
            s->workaround_bugs |= FF_BUG_DC_CLIP;

2176
        if (ctx->divx_version >= 0)
2177
            s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
2178
        if (ctx->divx_version == 501 && ctx->divx_build == 20020416)
2179 2180
            s->padding_bug_score = 256 * 256 * 256 * 64;

2181
        if (ctx->divx_version < 500U)
2182 2183
            s->workaround_bugs |= FF_BUG_EDGE;

2184
        if (ctx->divx_version >= 0)
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206
            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",
2207 2208
               s->workaround_bugs, ctx->lavc_build, ctx->xvid_build,
               ctx->divx_version, ctx->divx_build, s->divx_packed ? "p" : "");
2209 2210

#if HAVE_MMX
2211
    if (s->codec_id == AV_CODEC_ID_MPEG4 && ctx->xvid_build >= 0 &&
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
        avctx->idct_algo == FF_IDCT_AUTO &&
        (av_get_cpu_flags() & AV_CPU_FLAG_MMX)) {
        avctx->idct_algo = FF_IDCT_XVIDMMX;
        ff_dct_common_init(s);
        return 1;
    }
#endif
    return 0;
}

2222
static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2223
{
2224
    MpegEncContext *s = &ctx->m;
2225
    int time_incr, time_increment;
2226
    int64_t pts;
2227

2228
    s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;        /* pict type: I = 0 , P = 1 */
2229 2230
    if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
        s->vol_control_parameters == 0 && !(s->flags & CODEC_FLAG_LOW_DELAY)) {
2231
        av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
2232
        s->low_delay = 0;
2233 2234
    }

2235 2236 2237
    s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
    if (s->partitioned_frame)
        s->decode_mb = mpeg4_decode_partitioned_mb;
2238
    else
2239
        s->decode_mb = mpeg4_decode_mb;
2240

2241
    time_incr = 0;
2242 2243 2244 2245 2246
    while (get_bits1(gb) != 0)
        time_incr++;

    check_marker(gb, "before time_increment");

2247 2248
    if (ctx->time_increment_bits == 0 ||
        !(show_bits(gb, ctx->time_increment_bits + 1) & 1)) {
2249 2250 2251
        av_log(s->avctx, AV_LOG_ERROR,
               "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");

2252 2253 2254
        for (ctx->time_increment_bits = 1;
             ctx->time_increment_bits < 16;
             ctx->time_increment_bits++) {
2255 2256
            if (s->pict_type == AV_PICTURE_TYPE_P ||
                (s->pict_type == AV_PICTURE_TYPE_S &&
2257
                 ctx->vol_sprite_usage == GMC_SPRITE)) {
2258
                if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
2259
                    break;
2260
            } else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
2261
                break;
2262 2263
        }

2264
        av_log(s->avctx, AV_LOG_ERROR,
2265
               "my guess is %d bits ;)\n", ctx->time_increment_bits);
2266 2267
        if (s->avctx->time_base.den && 4*s->avctx->time_base.den < 1<<ctx->time_increment_bits) {
            s->avctx->time_base.den = 1<<ctx->time_increment_bits;
2268
        }
2269 2270
    }

2271 2272 2273
    if (IS_3IV1)
        time_increment = get_bits1(gb);        // FIXME investigate further
    else
2274
        time_increment = get_bits(gb, ctx->time_increment_bits);
2275 2276 2277 2278 2279 2280 2281

    if (s->pict_type != AV_PICTURE_TYPE_B) {
        s->last_time_base = s->time_base;
        s->time_base     += time_incr;
        s->time = s->time_base * s->avctx->time_base.den + time_increment;
        if (s->workaround_bugs & FF_BUG_UMP4) {
            if (s->time < s->last_non_b_time) {
2282 2283 2284
                /* header is not mpeg-4-compatible, broken encoder,
                 * trying to workaround */
                s->time_base++;
2285
                s->time += s->avctx->time_base.den;
2286 2287
            }
        }
2288 2289 2290 2291 2292 2293 2294 2295
        s->pp_time         = s->time - s->last_non_b_time;
        s->last_non_b_time = s->time;
    } else {
        s->time    = (s->last_time_base + time_incr) * s->avctx->time_base.den + time_increment;
        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) {
2296 2297 2298 2299 2300
            /* messed up order, maybe after seeking? skipping current b-frame */
            return FRAME_SKIPPED;
        }
        ff_mpeg4_init_direct_mv(s);

2301 2302 2303 2304 2305 2306 2307 2308
        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;
2309 2310 2311 2312
        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)
2313 2314 2315 2316
                return FRAME_SKIPPED;
        }
    }

2317
    if (s->avctx->time_base.num)
2318
        pts = ROUNDED_DIV(s->time, s->avctx->time_base.num);
2319
    else
2320
        pts = AV_NOPTS_VALUE;
2321
    if (s->avctx->debug&FF_DEBUG_PTS)
2322
        av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
2323
               pts);
2324 2325 2326 2327

    check_marker(gb, "before vop_coded");

    /* vop coded */
2328 2329
    if (get_bits1(gb) != 1) {
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2330 2331 2332
            av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
        return FRAME_SKIPPED;
    }
2333
    if (ctx->new_pred)
2334
        decode_new_pred(ctx, gb);
2335

2336
    if (ctx->shape != BIN_ONLY_SHAPE &&
2337 2338
                    (s->pict_type == AV_PICTURE_TYPE_P ||
                     (s->pict_type == AV_PICTURE_TYPE_S &&
2339
                      ctx->vol_sprite_usage == GMC_SPRITE))) {
2340 2341 2342 2343 2344
        /* rounding type for motion estimation */
        s->no_rounding = get_bits1(gb);
    } else {
        s->no_rounding = 0;
    }
2345 2346
    // FIXME reduced res stuff

2347
    if (ctx->shape != RECT_SHAPE) {
2348
        if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
            skip_bits(gb, 13);  /* width */
            skip_bits1(gb);     /* marker */
            skip_bits(gb, 13);  /* height */
            skip_bits1(gb);     /* marker */
            skip_bits(gb, 13);  /* hor_spat_ref */
            skip_bits1(gb);     /* marker */
            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

2365
    if (ctx->shape != BIN_ONLY_SHAPE) {
2366
        skip_bits_long(gb, ctx->cplx_estimation_trash_i);
2367
        if (s->pict_type != AV_PICTURE_TYPE_I)
2368
            skip_bits_long(gb, ctx->cplx_estimation_trash_p);
2369
        if (s->pict_type == AV_PICTURE_TYPE_B)
2370
            skip_bits_long(gb, ctx->cplx_estimation_trash_b);
2371

2372 2373 2374 2375
        if (get_bits_left(gb) < 3) {
            av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
            return -1;
        }
2376
        ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
        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) {
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
    } else {
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
    }

    if (s->pict_type == AV_PICTURE_TYPE_S &&
2397 2398
        (ctx->vol_sprite_usage == STATIC_SPRITE ||
         ctx->vol_sprite_usage == GMC_SPRITE)) {
2399
        if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
2400
            return AVERROR_INVALIDDATA;
2401
        if (ctx->sprite_brightness_change)
2402 2403
            av_log(s->avctx, AV_LOG_ERROR,
                   "sprite_brightness_change not supported\n");
2404
        if (ctx->vol_sprite_usage == STATIC_SPRITE)
2405 2406 2407
            av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
    }

2408
    if (ctx->shape != BIN_ONLY_SHAPE) {
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
        s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
        if (s->qscale == 0) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "Error, header damaged or not MPEG4 header (qscale=0)\n");
            return -1;  // makes no sense to continue, as there is nothing left from the image then
        }

        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,
                       "Error, header damaged or not MPEG4 header (f_code=0)\n");
2421
                s->f_code = 1;
2422 2423 2424 2425 2426 2427 2428
                return -1;  // makes no sense to continue, as there is nothing left from the image then
            }
        } else
            s->f_code = 1;

        if (s->pict_type == AV_PICTURE_TYPE_B) {
            s->b_code = get_bits(gb, 3);
2429 2430 2431 2432 2433 2434
            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;
                return -1; // makes no sense to continue, as the MV decoding will break very quickly
            }
2435 2436 2437 2438 2439
        } else
            s->b_code = 1;

        if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
            av_log(s->avctx, AV_LOG_DEBUG,
2440
                   "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",
2441 2442
                   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")),
2443
                   gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
2444
                   s->top_field_first, s->quarter_sample ? "q" : "h",
2445
                   s->data_partitioning, ctx->resync_marker,
2446
                   ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
2447
                   1 - s->no_rounding, s->vo_type,
2448
                   s->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
2449
                   ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
2450
                   ctx->cplx_estimation_trash_b,
2451 2452 2453
                   s->time,
                   time_increment
                  );
2454 2455
        }

2456
        if (!ctx->scalability) {
2457
            if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
2458 2459
                skip_bits1(gb);  // vop shape coding type
        } else {
2460
            if (ctx->enhancement_type) {
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472
                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
     * (divx4/xvid/opendivx). Note we cannot detect divx5 without b-frames
     * easily (although it's buggy too) */
    if (s->vo_type == 0 && s->vol_control_parameters == 0 &&
2473
        ctx->divx_version == -1 && s->picture_number == 0) {
2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489
        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;
2490 2491 2492
}

/**
2493
 * Decode mpeg4 headers.
2494 2495 2496 2497
 * @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
 */
2498
int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2499
{
2500
    MpegEncContext *s = &ctx->m;
2501
    unsigned startcode, v;
2502 2503 2504 2505

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

2506
    if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
2507
        skip_bits(gb, 24);
2508
        if (get_bits(gb, 8) == 0xF0)
2509 2510 2511 2512
            goto end;
    }

    startcode = 0xff;
2513 2514 2515
    for (;;) {
        if (get_bits_count(gb) >= gb->size_in_bits) {
            if (gb->size_in_bits == 8 &&
2516
                (ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
2517
                av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
2518 2519 2520
                return FRAME_SKIPPED;  // divx bug
            } else
                return -1;  // end of stream
2521 2522 2523 2524 2525 2526
        }

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

2527 2528
        if ((startcode & 0xFFFFFF00) != 0x100)
            continue;  // no startcode
2529

2530
        if (s->avctx->debug & FF_DEBUG_STARTCODE) {
2531
            av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 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
            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");
2586 2587 2588
            av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
        }

2589
        if (startcode >= 0x120 && startcode <= 0x12F) {
2590
            if (decode_vol_header(ctx, gb) < 0)
2591
                return -1;
2592
        } else if (startcode == USER_DATA_STARTCODE) {
2593
            decode_user_data(ctx, gb);
2594
        } else if (startcode == GOP_STARTCODE) {
2595
            mpeg4_decode_gop_header(s, gb);
2596
        } else if (startcode == VOS_STARTCODE) {
2597
            mpeg4_decode_profile_level(s, gb);
2598
        } else if (startcode == VOP_STARTCODE) {
2599 2600 2601 2602 2603 2604
            break;
        }

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

2606
end:
2607 2608 2609 2610
    if (s->flags & CODEC_FLAG_LOW_DELAY)
        s->low_delay = 1;
    s->avctx->has_b_frames = !s->low_delay;

2611
    return decode_vop_header(ctx, gb);
2612 2613
}

2614
av_cold void ff_mpeg4videodec_static_init(void) {
2615 2616 2617
    static int done = 0;

    if (!done) {
2618
        ff_init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
2619 2620
        ff_init_rl(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
        ff_init_rl(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
2621
        INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
2622 2623
        INIT_VLC_RL(ff_rvlc_rl_inter, 1072);
        INIT_VLC_RL(ff_rvlc_rl_intra, 1072);
2624
        INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2625 2626
                        &ff_mpeg4_DCtab_lum[0][1], 2, 1,
                        &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
2627
        INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2628 2629
                        &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
                        &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
2630
        INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2631 2632
                        &ff_sprite_trajectory_tab[0][1], 4, 2,
                        &ff_sprite_trajectory_tab[0][0], 4, 2, 128);
2633
        INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2634 2635
                        &ff_mb_type_b_tab[0][1], 2, 1,
                        &ff_mb_type_b_tab[0][0], 2, 1, 16);
2636
        done = 1;
2637
    }
2638 2639
}

2640 2641 2642 2643 2644
int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
{
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext    *s = &ctx->m;

2645 2646 2647
    /* 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 */
2648
    if (s->divx_packed) {
2649
        int current_pos     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);
2650 2651
        int startcode_found = 0;

2652 2653
        if (buf_size - current_pos > 7) {

2654
            int i;
2655 2656
            for (i = current_pos; i < buf_size - 4; i++)

2657 2658 2659 2660
                if (buf[i]     == 0 &&
                    buf[i + 1] == 0 &&
                    buf[i + 2] == 1 &&
                    buf[i + 3] == 0xB6) {
2661
                    startcode_found = !(buf[i + 4] & 0x40);
2662 2663 2664 2665 2666
                    break;
                }
        }

        if (startcode_found) {
2667
            av_fast_padded_malloc(&s->bitstream_buffer,
2668
                           &s->allocated_bitstream_buffer_size,
2669
                           buf_size - current_pos);
2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
            if (!s->bitstream_buffer)
                return AVERROR(ENOMEM);
            memcpy(s->bitstream_buffer, buf + current_pos,
                   buf_size - current_pos);
            s->bitstream_buffer_size = buf_size - current_pos;
        }
    }

    return 0;
}

2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
static int mpeg4_update_thread_context(AVCodecContext *dst,
                                       const AVCodecContext *src)
{
    Mpeg4DecContext *s = dst->priv_data;
    const Mpeg4DecContext *s1 = src->priv_data;

    int ret = ff_mpeg_update_thread_context(dst, src);

    if (ret < 0)
        return ret;

2692
    memcpy(((uint8_t*)s) + sizeof(MpegEncContext), ((uint8_t*)s1) + sizeof(MpegEncContext), sizeof(Mpeg4DecContext) - sizeof(MpegEncContext));
2693

2694 2695 2696
    return 0;
}

2697 2698
static av_cold int decode_init(AVCodecContext *avctx)
{
2699 2700
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext *s = &ctx->m;
2701 2702
    int ret;

2703 2704 2705 2706
    ctx->divx_version =
    ctx->divx_build   =
    ctx->xvid_build   =
    ctx->lavc_build   = -1;
2707

2708
    if ((ret = ff_h263_decode_init(avctx)) < 0)
2709 2710 2711
        return ret;

    ff_mpeg4videodec_static_init();
2712 2713

    s->h263_pred = 1;
2714
    s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
2715
    s->decode_mb = mpeg4_decode_mb;
2716
    ctx->time_increment_bits = 4; /* default value for broken headers */
2717

2718
    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
2719 2720
    avctx->internal->allocate_progress = 1;

2721 2722 2723
    return 0;
}

2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
static const AVProfile mpeg4_video_profiles[] = {
    { FF_PROFILE_MPEG4_SIMPLE,                    "Simple Profile" },
    { FF_PROFILE_MPEG4_SIMPLE_SCALABLE,           "Simple Scalable Profile" },
    { FF_PROFILE_MPEG4_CORE,                      "Core Profile" },
    { FF_PROFILE_MPEG4_MAIN,                      "Main Profile" },
    { FF_PROFILE_MPEG4_N_BIT,                     "N-bit Profile" },
    { FF_PROFILE_MPEG4_SCALABLE_TEXTURE,          "Scalable Texture Profile" },
    { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION,     "Simple Face Animation Profile" },
    { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE,    "Basic Animated Texture Profile" },
    { FF_PROFILE_MPEG4_HYBRID,                    "Hybrid Profile" },
    { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME,        "Advanced Real Time Simple Profile" },
    { FF_PROFILE_MPEG4_CORE_SCALABLE,             "Code Scalable Profile" },
    { FF_PROFILE_MPEG4_ADVANCED_CODING,           "Advanced Coding Profile" },
    { FF_PROFILE_MPEG4_ADVANCED_CORE,             "Advanced Core Profile" },
    { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
    { FF_PROFILE_MPEG4_SIMPLE_STUDIO,             "Simple Studio Profile" },
    { FF_PROFILE_MPEG4_ADVANCED_SIMPLE,           "Advanced Simple Profile" },
2741
    { FF_PROFILE_UNKNOWN },
2742 2743
};

2744
static const AVOption mpeg4_options[] = {
2745 2746
    {"quarter_sample", "1/4 subpel MC", offsetof(MpegEncContext, quarter_sample), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},
    {"divx_packed", "divx style packed b frames", offsetof(MpegEncContext, divx_packed), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},
2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763
    {NULL}
};

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

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

2764
AVCodec ff_mpeg4_decoder = {
2765
    .name                  = "mpeg4",
2766
    .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
2767
    .type                  = AVMEDIA_TYPE_VIDEO,
2768
    .id                    = AV_CODEC_ID_MPEG4,
2769
    .priv_data_size        = sizeof(Mpeg4DecContext),
2770 2771 2772 2773 2774 2775 2776
    .init                  = decode_init,
    .close                 = ff_h263_decode_end,
    .decode                = ff_h263_decode_frame,
    .capabilities          = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
                             CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
                             CODEC_CAP_FRAME_THREADS,
    .flush                 = ff_mpeg_flush,
2777
    .max_lowres            = 3,
2778
    .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
2779
    .profiles              = NULL_IF_CONFIG_SMALL(mpeg4_video_profiles),
2780
    .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg4_update_thread_context),
2781
    .priv_class = &mpeg4_class,
2782 2783
};

2784 2785 2786 2787

#if CONFIG_MPEG4_VDPAU_DECODER
AVCodec ff_mpeg4_vdpau_decoder = {
    .name           = "mpeg4_vdpau",
2788
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
2789 2790 2791 2792 2793 2794 2795 2796
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_MPEG4,
    .priv_data_size = sizeof(MpegEncContext),
    .init           = decode_init,
    .close          = ff_h263_decode_end,
    .decode         = ff_h263_decode_frame,
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
                      CODEC_CAP_HWACCEL_VDPAU,
2797
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_MPEG4,
2798 2799 2800 2801
                                                  AV_PIX_FMT_NONE },
    .priv_class     = &mpeg4_vdpau_class,
};
#endif