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

23 24
#define UNCHECKED_BITSTREAM_READER 1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

159
            s->gb = gb;
160

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

371 372 373 374 375 376 377
        if (shift_c < 0 || shift_y < 0 ||
            FFABS(s->sprite_offset[0][0]) >= INT_MAX >> shift_y  ||
            FFABS(s->sprite_offset[1][0]) >= INT_MAX >> shift_c  ||
            FFABS(s->sprite_offset[0][1]) >= INT_MAX >> shift_y  ||
            FFABS(s->sprite_offset[1][1]) >= INT_MAX >> shift_c
        ) {
            avpriv_request_sample(s->avctx, "Too large sprite shift or offset");
378
            goto overflow;
379 380
        }

381
        for (i = 0; i < 2; i++) {
382 383 384 385
            s->sprite_offset[0][i] *= 1 << shift_y;
            s->sprite_offset[1][i] *= 1 << shift_c;
            s->sprite_delta[0][i]  *= 1 << shift_y;
            s->sprite_delta[1][i]  *= 1 << shift_y;
386
            ctx->sprite_shift[i]     = 16;
387

388 389
        }
        for (i = 0; i < 2; i++) {
390 391 392 393 394
            int64_t sd[2] = {
                s->sprite_delta[i][0] - a * (1LL<<16),
                s->sprite_delta[i][1] - a * (1LL<<16)
            };

395 396
            if (llabs(s->sprite_offset[0][i] + s->sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
                llabs(s->sprite_offset[0][i] + s->sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
397 398
                llabs(s->sprite_offset[0][i] + s->sprite_delta[i][0] * (w+16LL) + s->sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
                llabs(s->sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
399 400 401 402 403 404
                llabs(s->sprite_delta[i][1] * (w+16LL)) >= INT_MAX ||
                llabs(sd[0]) >= INT_MAX ||
                llabs(sd[1]) >= INT_MAX ||
                llabs(s->sprite_offset[0][i] + sd[0] * (w+16LL)) >= INT_MAX ||
                llabs(s->sprite_offset[0][i] + sd[1] * (h+16LL)) >= INT_MAX ||
                llabs(s->sprite_offset[0][i] + sd[0] * (w+16LL) + sd[1] * (h+16LL)) >= INT_MAX
405
            ) {
406
                avpriv_request_sample(s->avctx, "Overflow on sprite points");
407
                goto overflow;
408
            }
409
        }
410
        s->real_sprite_warping_points = ctx->num_sprite_warping_points;
411
    }
412

413
    return 0;
414 415 416 417
overflow:
    memset(s->sprite_offset, 0, sizeof(s->sprite_offset));
    memset(s->sprite_delta, 0, sizeof(s->sprite_delta));
    return AVERROR_PATCHWELCOME;
418 419
}

420
static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
421
    MpegEncContext *s = &ctx->m;
422
    int len = FFMIN(ctx->time_increment_bits + 3, 15);
423 424 425 426

    get_bits(gb, len);
    if (get_bits1(gb))
        get_bits(gb, len);
427
    check_marker(s->avctx, gb, "after new_pred");
428 429 430 431

    return 0;
}

432
/**
433
 * Decode the next video packet.
434 435
 * @return <0 if something went wrong
 */
436
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
437
{
438 439
    MpegEncContext *s = &ctx->m;

440 441
    int mb_num_bits      = av_log2(s->mb_num - 1) + 1;
    int header_extension = 0, mb_num, len;
442 443

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

447 448 449
    for (len = 0; len < 32; len++)
        if (get_bits1(&s->gb))
            break;
450

451
    if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
452 453 454 455
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
        return -1;
    }

456
    if (ctx->shape != RECT_SHAPE) {
457 458
        header_extension = get_bits1(&s->gb);
        // FIXME more stuff here
459 460
    }

461 462 463 464
    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);
465 466 467
        return -1;
    }

468 469
    s->mb_x = mb_num % s->mb_width;
    s->mb_y = mb_num / s->mb_width;
470

471
    if (ctx->shape != BIN_ONLY_SHAPE) {
472 473 474
        int qscale = get_bits(&s->gb, s->quant_precision);
        if (qscale)
            s->chroma_qscale = s->qscale = qscale;
475 476
    }

477
    if (ctx->shape == RECT_SHAPE)
478 479 480 481
        header_extension = get_bits1(&s->gb);

    if (header_extension) {
        int time_incr = 0;
482 483 484 485

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

486
        check_marker(s->avctx, &s->gb, "before time_increment in video packed header");
487
        skip_bits(&s->gb, ctx->time_increment_bits);      /* time_increment */
488
        check_marker(s->avctx, &s->gb, "before vop_coding_type in video packed header");
489 490

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

493
        if (ctx->shape != BIN_ONLY_SHAPE) {
494
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
495 496
            // FIXME don't just ignore everything
            if (s->pict_type == AV_PICTURE_TYPE_S &&
497
                ctx->vol_sprite_usage == GMC_SPRITE) {
498
                if (mpeg4_decode_sprite_trajectory(ctx, &s->gb) < 0)
499
                    return AVERROR_INVALIDDATA;
500 501 502
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
            }

503
            // FIXME reduced res stuff here
504

505
            if (s->pict_type != AV_PICTURE_TYPE_I) {
506
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
507 508 509
                if (f_code == 0)
                    av_log(s->avctx, AV_LOG_ERROR,
                           "Error, video packet header damaged (f_code=0)\n");
510
            }
511
            if (s->pict_type == AV_PICTURE_TYPE_B) {
512
                int b_code = get_bits(&s->gb, 3);
513 514 515
                if (b_code == 0)
                    av_log(s->avctx, AV_LOG_ERROR,
                           "Error, video packet header damaged (b_code=0)\n");
516 517 518
            }
        }
    }
519
    if (ctx->new_pred)
520
        decode_new_pred(ctx, &s->gb);
521 522 523 524 525

    return 0;
}

/**
526
 * Get the average motion vector for a GMC MB.
527
 * @param n either 0 for the x component or 1 for y
528
 * @return the average MV for a GMC MB
529
 */
530
static inline int get_amv(Mpeg4DecContext *ctx, int n)
531
{
532
    MpegEncContext *s = &ctx->m;
533
    int x, y, mb_v, sum, dx, dy, shift;
534 535
    int len     = 1 << (s->f_code + 4);
    const int a = s->sprite_warping_accuracy;
536

537
    if (s->workaround_bugs & FF_BUG_AMV)
538 539
        len >>= s->quarter_sample;

540
    if (s->real_sprite_warping_points == 1) {
541
        if (ctx->divx_version == 500 && ctx->divx_build == 413)
542 543
            sum = s->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
        else
544
            sum = RSHIFT(s->sprite_offset[0][n] * (1 << s->quarter_sample), a);
545 546 547
    } else {
        dx    = s->sprite_delta[n][0];
        dy    = s->sprite_delta[n][1];
548
        shift = ctx->sprite_shift[0];
549 550
        if (n)
            dy -= 1 << (shift + a + 1);
551
        else
552 553 554 555 556
            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++) {
557 558
            int v;

559 560 561 562 563
            v = mb_v + dy * y;
            // FIXME optimize
            for (x = 0; x < 16; x++) {
                sum += v >> shift;
                v   += dx;
564 565
            }
        }
566
        sum = RSHIFT(sum, a + 8 - s->quarter_sample);
567 568
    }

569 570 571 572
    if (sum < -len)
        sum = -len;
    else if (sum >= len)
        sum = len - 1;
573 574 575 576 577

    return sum;
}

/**
578
 * Decode the dc value.
579 580 581 582
 * @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
 */
583
static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
584 585 586 587 588 589 590
{
    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);
591 592

    if (code < 0 || code > 9 /* && s->nbit < 9 */) {
593 594 595
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
        return -1;
    }
596

597 598 599
    if (code == 0) {
        level = 0;
    } else {
600 601 602 603 604 605
        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));
606
                else
607
                    level = -get_bits(&s->gb, code - 1) - (1 << (code - 1));
608
            }
609
        } else {
610 611 612
            level = get_xbits(&s->gb, code);
        }

613 614
        if (code > 8) {
            if (get_bits1(&s->gb) == 0) { /* marker */
615
                if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
616 617 618 619 620 621 622 623 624 625 626
                    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);
}

/**
627
 * Decode first partition.
628 629
 * @return number of MBs decoded or <0 if an error occurred
 */
630
static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
631
{
632
    MpegEncContext *s = &ctx->m;
633
    int mb_num = 0;
634 635 636
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };

    /* decode first partition */
637 638
    s->first_slice_line = 1;
    for (; s->mb_y < s->mb_height; s->mb_y++) {
639
        ff_init_block_index(s);
640 641
        for (; s->mb_x < s->mb_width; s->mb_x++) {
            const int xy = s->mb_x + s->mb_y * s->mb_stride;
642
            int cbpc;
643
            int dir = 0;
644 645 646

            mb_num++;
            ff_update_block_index(s);
647 648
            if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
                s->first_slice_line = 0;
649

650
            if (s->pict_type == AV_PICTURE_TYPE_I) {
651 652
                int i;

653 654 655
                do {
                    if (show_bits_long(&s->gb, 19) == DC_MARKER)
                        return mb_num - 1;
656

657
                    cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
658 659
                    if (cbpc < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
660
                               "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
661 662
                        return -1;
                    }
663
                } while (cbpc == 8);
664

665
                s->cbp_table[xy]               = cbpc & 3;
666
                s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
667
                s->mb_intra                    = 1;
668

669
                if (cbpc & 4)
670 671
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);

672 673 674 675
                s->current_picture.qscale_table[xy] = s->qscale;

                s->mbintra_table[xy] = 1;
                for (i = 0; i < 6; i++) {
676
                    int dc_pred_dir;
677 678 679 680
                    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);
681 682
                        return -1;
                    }
683 684 685
                    dir <<= 1;
                    if (dc_pred_dir)
                        dir |= 1;
686
                }
687 688
                s->pred_dir_table[xy] = dir;
            } else { /* P/S_TYPE */
689
                int mx, my, pred_x, pred_y, bits;
690 691
                int16_t *const mot_val = s->current_picture.motion_val[0][s->block_index[0]];
                const int stride       = s->b8_stride * 2;
692 693

try_again:
694 695 696 697
                bits = show_bits(&s->gb, 17);
                if (bits == MOTION_MARKER)
                    return mb_num - 1;

698
                skip_bits1(&s->gb);
699
                if (bits & 0x10000) {
700
                    /* skip mb */
701
                    if (s->pict_type == AV_PICTURE_TYPE_S &&
702
                        ctx->vol_sprite_usage == GMC_SPRITE) {
703 704 705 706
                        s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                         MB_TYPE_16x16 |
                                                         MB_TYPE_GMC   |
                                                         MB_TYPE_L0;
707 708
                        mx = get_amv(ctx, 0);
                        my = get_amv(ctx, 1);
709 710 711 712 713
                    } else {
                        s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                         MB_TYPE_16x16 |
                                                         MB_TYPE_L0;
                        mx = my = 0;
714
                    }
715 716 717 718 719 720 721 722 723 724
                    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])
725 726 727 728
                        ff_clean_intra_table_entries(s);
                    continue;
                }

729
                cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
730 731
                if (cbpc < 0) {
                    av_log(s->avctx, AV_LOG_ERROR,
732
                           "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
733 734
                    return -1;
                }
735
                if (cbpc == 20)
736 737
                    goto try_again;

738
                s->cbp_table[xy] = cbpc & (8 + 3);  // 8 is dquant
739 740 741

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

742
                if (s->mb_intra) {
743
                    s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
744 745 746 747 748 749 750 751 752 753 754
                    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])
755 756
                        ff_clean_intra_table_entries(s);

757
                    if (s->pict_type == AV_PICTURE_TYPE_S &&
758
                        ctx->vol_sprite_usage == GMC_SPRITE &&
759 760 761 762
                        (cbpc & 16) == 0)
                        s->mcsel = get_bits1(&s->gb);
                    else
                        s->mcsel = 0;
763 764 765 766

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

767
                        ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
768
                        if (!s->mcsel) {
769
                            mx = ff_h263_decode_motion(s, pred_x, s->f_code);
770 771 772
                            if (mx >= 0xffff)
                                return -1;

773
                            my = ff_h263_decode_motion(s, pred_y, s->f_code);
774 775
                            if (my >= 0xffff)
                                return -1;
776 777
                            s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
                                                             MB_TYPE_L0;
778
                        } else {
779 780
                            mx = get_amv(ctx, 0);
                            my = get_amv(ctx, 1);
781 782 783
                            s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
                                                             MB_TYPE_GMC   |
                                                             MB_TYPE_L0;
784 785
                        }

786 787 788 789 790 791 792 793
                        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;
794 795
                    } else {
                        int i;
796 797 798 799
                        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);
800
                            mx = ff_h263_decode_motion(s, pred_x, s->f_code);
801 802 803
                            if (mx >= 0xffff)
                                return -1;

804
                            my = ff_h263_decode_motion(s, pred_y, s->f_code);
805 806 807 808 809 810 811 812 813
                            if (my >= 0xffff)
                                return -1;
                            mot_val[0] = mx;
                            mot_val[1] = my;
                        }
                    }
                }
            }
        }
814
        s->mb_x = 0;
815 816 817 818 819 820 821 822 823
    }

    return mb_num;
}

/**
 * decode second partition.
 * @return <0 if an error occurred
 */
824 825 826
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
{
    int mb_num = 0;
827 828
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };

829 830 831
    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++) {
832
        ff_init_block_index(s);
833 834
        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;
835 836 837

            mb_num++;
            ff_update_block_index(s);
838 839 840 841 842 843 844 845 846
            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);
847 848 849
                    return -1;
                }

850 851 852
                s->cbp_table[xy]               |= cbpy << 2;
                s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
            } else { /* P || S_TYPE */
853
                if (IS_INTRA(s->current_picture.mb_type[xy])) {
854 855
                    int i;
                    int dir     = 0;
856
                    int ac_pred = get_bits1(&s->gb);
857
                    int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
858

859 860 861
                    if (cbpy < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
862 863 864
                        return -1;
                    }

865
                    if (s->cbp_table[xy] & 8)
866
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
867
                    s->current_picture.qscale_table[xy] = s->qscale;
868

869
                    for (i = 0; i < 6; i++) {
870
                        int dc_pred_dir;
871 872 873 874
                        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);
875 876
                            return -1;
                        }
877 878 879
                        dir <<= 1;
                        if (dc_pred_dir)
                            dir |= 1;
880
                    }
881 882 883 884
                    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;
885 886
                } else if (IS_SKIP(s->current_picture.mb_type[xy])) {
                    s->current_picture.qscale_table[xy] = s->qscale;
887 888
                    s->cbp_table[xy]                    = 0;
                } else {
889
                    int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
890

891 892 893
                    if (cbpy < 0) {
                        av_log(s->avctx, AV_LOG_ERROR,
                               "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
894 895 896
                        return -1;
                    }

897
                    if (s->cbp_table[xy] & 8)
898
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
899
                    s->current_picture.qscale_table[xy] = s->qscale;
900

901 902
                    s->cbp_table[xy] &= 3;  // remove dquant
                    s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
903 904 905
                }
            }
        }
906 907 908
        if (mb_num >= mb_count)
            return 0;
        s->mb_x = 0;
909 910 911 912 913
    }
    return 0;
}

/**
914
 * Decode the first and second partition.
915 916
 * @return <0 if error (and sets error type in the error_status_table)
 */
917
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
918
{
919
    MpegEncContext *s = &ctx->m;
920
    int mb_num;
921 922
    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;
923

924
    mb_num = mpeg4_decode_partition_a(ctx);
925
    if (mb_num <= 0) {
926 927
        ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                        s->mb_x, s->mb_y, part_a_error);
928 929 930
        return -1;
    }

931
    if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) {
932
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
933 934
        ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                        s->mb_x, s->mb_y, part_a_error);
935 936 937
        return -1;
    }

938
    s->mb_num_left = mb_num;
939

940 941
    if (s->pict_type == AV_PICTURE_TYPE_I) {
        while (show_bits(&s->gb, 9) == 1)
942
            skip_bits(&s->gb, 9);
943 944 945 946
        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);
947 948
            return -1;
        }
949 950
    } else {
        while (show_bits(&s->gb, 10) == 1)
951
            skip_bits(&s->gb, 10);
952 953 954 955
        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);
956 957 958
            return -1;
        }
    }
959 960
    ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
                    s->mb_x - 1, s->mb_y, part_a_end);
961

962 963 964 965
    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);
966
        return -1;
967 968 969 970
    } 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);
971 972 973 974 975 976
    }

    return 0;
}

/**
977
 * Decode a block.
978 979
 * @return <0 if an error occurred
 */
980
static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
981
                                     int n, int coded, int intra, int rvlc)
982
{
983
    MpegEncContext *s = &ctx->m;
984
    int level, i, last, run, qmul, qadd;
985
    int av_uninit(dc_pred_dir);
986 987 988 989 990 991 992
    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) {
993
        if (ctx->use_intra_dc_vlc) {
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
            /* 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 {
1010 1011
            i = -1;
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
        }
        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 {
1029
            scan_table = s->intra_scantable.permutated;
1030 1031 1032
        }
        qmul = 1;
        qadd = 0;
1033 1034 1035 1036 1037 1038
    } else {
        i = -1;
        if (!coded) {
            s->block_last_index[n] = i;
            return 0;
        }
1039 1040 1041 1042
        if (rvlc)
            rl = &ff_rvlc_rl_inter;
        else
            rl = &ff_h263_rl_inter;
1043 1044 1045

        scan_table = s->intra_scantable.permutated;

1046 1047 1048 1049
        if (s->mpeg_quant) {
            qmul = 1;
            qadd = 0;
            if (rvlc)
1050
                rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
1051
            else
1052
                rl_vlc = ff_h263_rl_inter.rl_vlc[0];
1053
        } else {
1054 1055
            qmul = s->qscale << 1;
            qadd = (s->qscale - 1) | 1;
1056
            if (rvlc)
1057
                rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
1058
            else
1059
                rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
1060 1061
        }
    }
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
    {
        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);
1076

1077 1078 1079 1080
                    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);
1081 1082
                    UPDATE_CACHE(re, &s->gb);

1083 1084 1085 1086 1087 1088
                    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);
1089

1090 1091
                    level = SHOW_UBITS(re, &s->gb, 11);
                    SKIP_CACHE(re, &s->gb, 11);
1092

1093 1094 1095
                    if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
                        av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
                        return -1;
1096
                    }
1097
                    SKIP_CACHE(re, &s->gb, 5);
1098

1099 1100 1101
                    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);
1102

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
                    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");
1130
                                    if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
1131
                                        return -1;
1132 1133
                                }
                                SKIP_CACHE(re, &s->gb, 1);
1134

1135 1136
                                level = SHOW_SBITS(re, &s->gb, 12);
                                SKIP_CACHE(re, &s->gb, 12);
1137

1138 1139 1140
                                if (SHOW_UBITS(re, &s->gb, 1) == 0) {
                                    av_log(s->avctx, AV_LOG_ERROR,
                                           "2. marker bit missing in 3. esc\n");
1141
                                    if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
1142
                                        return -1;
1143
                                }
1144

1145
                                SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
1146 1147 1148
                            }

#if 0
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
                            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;
                                        }
                                    }
1167 1168 1169
                                }
                            }
#endif
1170 1171 1172 1173 1174 1175
                            if (level > 0)
                                level = level * qmul + qadd;
                            else
                                level = level * qmul - qadd;

                            if ((unsigned)(level + 2048) > 4095) {
1176
                                if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) {
1177 1178 1179 1180 1181 1182 1183 1184
                                    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;
1185
                            }
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196

                            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);
1197
                        }
1198 1199 1200 1201 1202 1203 1204 1205
                    } 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);
1206 1207 1208
                    }
                }
            } else {
1209
                i    += run;
1210 1211 1212
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                LAST_SKIP_BITS(re, &s->gb, 1);
            }
1213
            ff_tlog(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
            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;
1224 1225 1226 1227
            }

            block[scan_table[i]] = level;
        }
1228
        CLOSE_READER(re, &s->gb);
1229
    }
1230 1231

not_coded:
1232
    if (intra) {
1233
        if (!ctx->use_intra_dc_vlc) {
1234 1235
            block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);

1236
            i -= i >> 31;  // if (i == -1) i = 0;
1237 1238
        }

1239
        ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1240 1241
        if (s->ac_pred)
            i = 63;  // FIXME not optimal
1242 1243 1244 1245 1246 1247 1248 1249 1250
    }
    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
1251
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
1252
{
1253
    Mpeg4DecContext *ctx = (Mpeg4DecContext *)s;
1254
    int cbp, mb_type;
1255
    const int xy = s->mb_x + s->mb_y * s->mb_stride;
1256

1257
    mb_type = s->current_picture.mb_type[xy];
1258
    cbp     = s->cbp_table[xy];
1259

1260
    ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1261

1262
    if (s->current_picture.qscale_table[xy] != s->qscale)
1263
        ff_set_qscale(s, s->current_picture.qscale_table[xy]);
1264

1265 1266
    if (s->pict_type == AV_PICTURE_TYPE_P ||
        s->pict_type == AV_PICTURE_TYPE_S) {
1267
        int i;
1268
        for (i = 0; i < 4; i++) {
1269 1270
            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];
1271 1272 1273 1274 1275
        }
        s->mb_intra = IS_INTRA(mb_type);

        if (IS_SKIP(mb_type)) {
            /* skip mb */
1276
            for (i = 0; i < 6; i++)
1277
                s->block_last_index[i] = -1;
1278
            s->mv_dir  = MV_DIR_FORWARD;
1279
            s->mv_type = MV_TYPE_16X16;
1280
            if (s->pict_type == AV_PICTURE_TYPE_S
1281
                && ctx->vol_sprite_usage == GMC_SPRITE) {
1282
                s->mcsel      = 1;
1283
                s->mb_skipped = 0;
1284 1285
            } else {
                s->mcsel      = 0;
1286 1287
                s->mb_skipped = 1;
            }
1288
        } else if (s->mb_intra) {
1289
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
1290 1291
        } else if (!s->mb_intra) {
            // s->mcsel = 0;  // FIXME do we need to init that?
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301

            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;
1302
        s->ac_pred  = IS_ACPRED(s->current_picture.mb_type[xy]);
1303 1304 1305 1306
    }

    if (!IS_SKIP(mb_type)) {
        int i;
1307
        s->bdsp.clear_blocks(s->block[0]);
1308 1309
        /* decode each block */
        for (i = 0; i < 6; i++) {
1310
            if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, s->mb_intra, ctx->rvlc) < 0) {
1311 1312 1313
                av_log(s->avctx, AV_LOG_ERROR,
                       "texture corrupted at %d %d %d\n",
                       s->mb_x, s->mb_y, s->mb_intra);
1314 1315
                return -1;
            }
1316
            cbp += cbp;
1317 1318 1319 1320
        }
    }

    /* per-MB end of slice check */
1321
    if (--s->mb_num_left <= 0) {
1322
        if (mpeg4_is_resync(ctx))
1323 1324 1325
            return SLICE_END;
        else
            return SLICE_NOEND;
1326
    } else {
1327
        if (mpeg4_is_resync(ctx)) {
1328 1329
            const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
            if (s->cbp_table[xy + delta])
1330 1331 1332 1333 1334 1335
                return SLICE_END;
        }
        return SLICE_OK;
    }
}

1336
static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
1337
{
1338
    Mpeg4DecContext *ctx = (Mpeg4DecContext *)s;
1339 1340
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
    int16_t *mot_val;
1341
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1342
    const int xy = s->mb_x + s->mb_y * s->mb_stride;
1343

1344
    av_assert2(s->h263_pred);
1345

1346 1347 1348
    if (s->pict_type == AV_PICTURE_TYPE_P ||
        s->pict_type == AV_PICTURE_TYPE_S) {
        do {
1349 1350 1351
            if (get_bits1(&s->gb)) {
                /* skip mb */
                s->mb_intra = 0;
1352
                for (i = 0; i < 6; i++)
1353
                    s->block_last_index[i] = -1;
1354
                s->mv_dir  = MV_DIR_FORWARD;
1355
                s->mv_type = MV_TYPE_16X16;
1356
                if (s->pict_type == AV_PICTURE_TYPE_S &&
1357
                    ctx->vol_sprite_usage == GMC_SPRITE) {
1358 1359 1360 1361 1362
                    s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                     MB_TYPE_GMC   |
                                                     MB_TYPE_16x16 |
                                                     MB_TYPE_L0;
                    s->mcsel       = 1;
1363 1364
                    s->mv[0][0][0] = get_amv(ctx, 0);
                    s->mv[0][0][1] = get_amv(ctx, 1);
1365 1366 1367 1368 1369 1370
                    s->mb_skipped  = 0;
                } else {
                    s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                                     MB_TYPE_16x16 |
                                                     MB_TYPE_L0;
                    s->mcsel       = 0;
1371 1372
                    s->mv[0][0][0] = 0;
                    s->mv[0][0][1] = 0;
1373
                    s->mb_skipped  = 1;
1374 1375 1376
                }
                goto end;
            }
1377
            cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1378 1379
            if (cbpc < 0) {
                av_log(s->avctx, AV_LOG_ERROR,
1380
                       "mcbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1381 1382
                return -1;
            }
1383
        } while (cbpc == 20);
1384

1385
        s->bdsp.clear_blocks(s->block[0]);
1386
        dquant      = cbpc & 8;
1387
        s->mb_intra = ((cbpc & 4) != 0);
1388 1389
        if (s->mb_intra)
            goto intra;
1390

1391
        if (s->pict_type == AV_PICTURE_TYPE_S &&
1392
            ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
1393 1394 1395
            s->mcsel = get_bits1(&s->gb);
        else
            s->mcsel = 0;
1396
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
1397 1398 1399 1400 1401
        if (cbpy < 0) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "P cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
            return AVERROR_INVALIDDATA;
        }
1402 1403

        cbp = (cbpc & 3) | (cbpy << 2);
1404
        if (dquant)
1405
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1406 1407 1408
        if ((!s->progressive_sequence) &&
            (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE)))
            s->interlaced_dct = get_bits1(&s->gb);
1409 1410 1411

        s->mv_dir = MV_DIR_FORWARD;
        if ((cbpc & 16) == 0) {
1412 1413 1414 1415
            if (s->mcsel) {
                s->current_picture.mb_type[xy] = MB_TYPE_GMC   |
                                                 MB_TYPE_16x16 |
                                                 MB_TYPE_L0;
1416
                /* 16x16 global motion prediction */
1417
                s->mv_type     = MV_TYPE_16X16;
1418 1419
                mx             = get_amv(ctx, 0);
                my             = get_amv(ctx, 1);
1420 1421
                s->mv[0][0][0] = mx;
                s->mv[0][0][1] = my;
1422 1423 1424 1425
            } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
                s->current_picture.mb_type[xy] = MB_TYPE_16x8 |
                                                 MB_TYPE_L0   |
                                                 MB_TYPE_INTERLACED;
1426
                /* 16x8 field motion prediction */
1427
                s->mv_type = MV_TYPE_FIELD;
1428

1429 1430
                s->field_select[0][0] = get_bits1(&s->gb);
                s->field_select[0][1] = get_bits1(&s->gb);
1431

1432
                ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1433

1434
                for (i = 0; i < 2; i++) {
1435
                    mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1436 1437 1438
                    if (mx >= 0xffff)
                        return -1;

1439
                    my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
1440 1441 1442 1443 1444 1445
                    if (my >= 0xffff)
                        return -1;

                    s->mv[0][i][0] = mx;
                    s->mv[0][i][1] = my;
                }
1446
            } else {
1447
                s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
1448 1449
                /* 16x16 motion prediction */
                s->mv_type = MV_TYPE_16X16;
1450 1451
                ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
                mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1452 1453 1454 1455

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

1456
                my = ff_h263_decode_motion(s, pred_y, s->f_code);
1457 1458 1459 1460 1461 1462 1463

                if (my >= 0xffff)
                    return -1;
                s->mv[0][0][0] = mx;
                s->mv[0][0][1] = my;
            }
        } else {
1464
            s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
1465 1466
            s->mv_type                     = MV_TYPE_8X8;
            for (i = 0; i < 4; i++) {
1467
                mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1468
                mx      = ff_h263_decode_motion(s, pred_x, s->f_code);
1469 1470 1471
                if (mx >= 0xffff)
                    return -1;

1472
                my = ff_h263_decode_motion(s, pred_y, s->f_code);
1473 1474 1475 1476
                if (my >= 0xffff)
                    return -1;
                s->mv[0][i][0] = mx;
                s->mv[0][i][1] = my;
1477 1478
                mot_val[0]     = mx;
                mot_val[1]     = my;
1479 1480
            }
        }
1481 1482 1483
    } else if (s->pict_type == AV_PICTURE_TYPE_B) {
        int modb1;   // first bit of modb
        int modb2;   // second bit of modb
1484 1485
        int mb_type;

1486 1487
        s->mb_intra = 0;  // B-frames never contain intra blocks
        s->mcsel    = 0;  //      ...               true gmc blocks
1488

1489 1490 1491 1492 1493 1494
        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;
1495
            }
1496

1497
            ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);
1498 1499
        }

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

1503 1504 1505
        if (s->mb_skipped) {
            /* skip mb */
            for (i = 0; i < 6; i++)
1506 1507
                s->block_last_index[i] = -1;

1508 1509 1510 1511 1512
            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] =
1513
            s->mv[1][0][1] = 0;
1514 1515 1516
            s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
                                             MB_TYPE_16x16 |
                                             MB_TYPE_L0;
1517 1518 1519
            goto end;
        }

1520 1521 1522 1523 1524 1525 1526 1527 1528
        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) {
1529 1530 1531
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
                return -1;
            }
1532 1533 1534 1535
            mb_type = mb_type_b_map[mb_type];
            if (modb2) {
                cbp = 0;
            } else {
1536
                s->bdsp.clear_blocks(s->block[0]);
1537
                cbp = get_bits(&s->gb, 6);
1538 1539 1540
            }

            if ((!IS_DIRECT(mb_type)) && cbp) {
1541 1542
                if (get_bits1(&s->gb))
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2);
1543 1544
            }

1545 1546 1547
            if (!s->progressive_sequence) {
                if (cbp)
                    s->interlaced_dct = get_bits1(&s->gb);
1548

1549
                if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) {
1550 1551 1552
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
                    mb_type &= ~MB_TYPE_16x16;

1553 1554 1555
                    if (USES_LIST(mb_type, 0)) {
                        s->field_select[0][0] = get_bits1(&s->gb);
                        s->field_select[0][1] = get_bits1(&s->gb);
1556
                    }
1557 1558 1559
                    if (USES_LIST(mb_type, 1)) {
                        s->field_select[1][0] = get_bits1(&s->gb);
                        s->field_select[1][1] = get_bits1(&s->gb);
1560 1561 1562 1563 1564
                    }
                }
            }

            s->mv_dir = 0;
1565 1566
            if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) {
                s->mv_type = MV_TYPE_16X16;
1567

1568
                if (USES_LIST(mb_type, 0)) {
1569 1570
                    s->mv_dir = MV_DIR_FORWARD;

1571 1572
                    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);
1573 1574 1575 1576 1577 1578
                    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;
1579 1580
                }

1581
                if (USES_LIST(mb_type, 1)) {
1582 1583
                    s->mv_dir |= MV_DIR_BACKWARD;

1584 1585
                    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);
1586 1587 1588 1589 1590 1591
                    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;
1592
                }
1593 1594
            } else if (!IS_DIRECT(mb_type)) {
                s->mv_type = MV_TYPE_FIELD;
1595

1596
                if (USES_LIST(mb_type, 0)) {
1597 1598
                    s->mv_dir = MV_DIR_FORWARD;

1599 1600 1601 1602 1603 1604
                    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;
1605 1606 1607
                    }
                }

1608
                if (USES_LIST(mb_type, 1)) {
1609 1610
                    s->mv_dir |= MV_DIR_BACKWARD;

1611 1612 1613 1614 1615 1616
                    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;
1617 1618 1619 1620 1621
                    }
                }
            }
        }

1622 1623 1624 1625 1626
        if (IS_DIRECT(mb_type)) {
            if (IS_SKIP(mb_type)) {
                mx =
                my = 0;
            } else {
1627 1628
                mx = ff_h263_decode_motion(s, 0, 1);
                my = ff_h263_decode_motion(s, 0, 1);
1629 1630 1631
            }

            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1632
            mb_type  |= ff_mpeg4_set_direct_mv(s, mx, my);
1633
        }
1634
        s->current_picture.mb_type[xy] = mb_type;
1635
    } else { /* I-Frame */
1636
        do {
1637
            cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1638 1639 1640
            if (cbpc < 0) {
                av_log(s->avctx, AV_LOG_ERROR,
                       "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1641 1642
                return -1;
            }
1643
        } while (cbpc == 8);
1644 1645 1646

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

1648 1649
intra:
        s->ac_pred = get_bits1(&s->gb);
1650
        if (s->ac_pred)
1651
            s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1652
        else
1653
            s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1654

1655
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1656 1657 1658
        if (cbpy < 0) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1659 1660 1661 1662
            return -1;
        }
        cbp = (cbpc & 3) | (cbpy << 2);

1663
        ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1664

1665
        if (dquant)
1666 1667
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);

1668 1669
        if (!s->progressive_sequence)
            s->interlaced_dct = get_bits1(&s->gb);
1670

1671
        s->bdsp.clear_blocks(s->block[0]);
1672 1673
        /* decode each block */
        for (i = 0; i < 6; i++) {
1674
            if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 1, 0) < 0)
1675
                return -1;
1676
            cbp += cbp;
1677 1678 1679 1680 1681 1682
        }
        goto end;
    }

    /* decode each block */
    for (i = 0; i < 6; i++) {
1683
        if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 0, 0) < 0)
1684
            return -1;
1685
        cbp += cbp;
1686 1687
    }

1688 1689 1690
end:
    /* per-MB end of slice check */
    if (s->codec_id == AV_CODEC_ID_MPEG4) {
1691
        int next = mpeg4_is_resync(ctx);
1692
        if (next) {
1693
            if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
1694 1695 1696
                return -1;
            } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
                return SLICE_END;
1697

1698
            if (s->pict_type == AV_PICTURE_TYPE_B) {
1699
                const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1700
                ff_thread_await_progress(&s->next_picture_ptr->tf,
1701 1702 1703
                                         (s->mb_x + delta >= s->mb_width)
                                         ? FFMIN(s->mb_y + 1, s->mb_height - 1)
                                         : s->mb_y, 0);
1704
                if (s->next_picture.mbskip_table[xy + delta])
1705 1706 1707 1708
                    return SLICE_OK;
            }

            return SLICE_END;
1709 1710 1711 1712 1713 1714
        }
    }

    return SLICE_OK;
}

1715 1716
static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
{
1717 1718
    int hours, minutes, seconds;

1719
    if (!show_bits(gb, 23)) {
1720 1721 1722 1723
        av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
        return -1;
    }

1724 1725
    hours   = get_bits(gb, 5);
    minutes = get_bits(gb, 6);
1726
    check_marker(s->avctx, gb, "in gop_header");
1727
    seconds = get_bits(gb, 6);
1728

1729
    s->time_base = seconds + 60*(minutes + 60*hours);
1730 1731 1732 1733 1734 1735 1736

    skip_bits1(gb);
    skip_bits1(gb);

    return 0;
}

1737 1738
static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb)
{
1739

1740 1741
    s->avctx->profile = get_bits(gb, 4);
    s->avctx->level   = get_bits(gb, 4);
1742

1743 1744 1745 1746
    // for Simple profile, level 0
    if (s->avctx->profile == 0 && s->avctx->level == 8) {
        s->avctx->level = 0;
    }
1747

1748
    return 0;
1749 1750
}

1751
static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
1752
{
1753
    MpegEncContext *s = &ctx->m;
1754 1755 1756
    int width, height, vo_ver_id;

    /* vol header */
1757 1758 1759 1760 1761
    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 */
1762 1763 1764
    } else {
        vo_ver_id = 1;
    }
1765 1766 1767 1768 1769 1770
    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];
1771 1772
    }

1773
    if ((ctx->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
1774 1775
        int chroma_format = get_bits(gb, 2);
        if (chroma_format != CHROMA_420)
1776
            av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
1777 1778 1779

        s->low_delay = get_bits1(gb);
        if (get_bits1(gb)) {    /* vbv parameters */
1780
            get_bits(gb, 15);   /* first_half_bitrate */
1781
            check_marker(s->avctx, gb, "after first_half_bitrate");
1782
            get_bits(gb, 15);   /* latter_half_bitrate */
1783
            check_marker(s->avctx, gb, "after latter_half_bitrate");
1784
            get_bits(gb, 15);   /* first_half_vbv_buffer_size */
1785
            check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
1786 1787
            get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
            get_bits(gb, 11);   /* first_half_vbv_occupancy */
1788
            check_marker(s->avctx, gb, "after first_half_vbv_occupancy");
1789
            get_bits(gb, 15);   /* latter_half_vbv_occupancy */
1790
            check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
1791
        }
1792 1793
    } else {
        /* is setting low delay flag only once the smartest thing to do?
1794
         * low delay detection will not be overridden. */
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804
        if (s->picture_number == 0) {
            switch(s->vo_type) {
            case SIMPLE_VO_TYPE:
            case ADV_SIMPLE_VO_TYPE:
                s->low_delay = 1;
                break;
            default:
                s->low_delay = 0;
            }
        }
1805 1806
    }

1807 1808
    ctx->shape = get_bits(gb, 2); /* vol shape */
    if (ctx->shape != RECT_SHAPE)
1809
        av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
1810
    if (ctx->shape == GRAY_SHAPE && vo_ver_id != 1) {
1811
        av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
1812
        skip_bits(gb, 4);  /* video_object_layer_shape_extension */
1813 1814
    }

1815
    check_marker(s->avctx, gb, "before time_increment_resolution");
1816

1817 1818 1819
    s->avctx->framerate.num = get_bits(gb, 16);
    if (!s->avctx->framerate.num) {
        av_log(s->avctx, AV_LOG_ERROR, "framerate==0\n");
1820
        return AVERROR_INVALIDDATA;
1821 1822
    }

1823
    ctx->time_increment_bits = av_log2(s->avctx->framerate.num - 1) + 1;
1824 1825
    if (ctx->time_increment_bits < 1)
        ctx->time_increment_bits = 1;
1826

1827
    check_marker(s->avctx, gb, "before fixed_vop_rate");
1828

1829
    if (get_bits1(gb) != 0)     /* fixed_vop_rate  */
1830
        s->avctx->framerate.den = get_bits(gb, ctx->time_increment_bits);
1831
    else
1832
        s->avctx->framerate.den = 1;
1833

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

1836
    ctx->t_frame = 0;
1837

1838 1839
    if (ctx->shape != BIN_ONLY_SHAPE) {
        if (ctx->shape == RECT_SHAPE) {
1840
            check_marker(s->avctx, gb, "before width");
1841
            width = get_bits(gb, 13);
1842
            check_marker(s->avctx, gb, "before height");
1843
            height = get_bits(gb, 13);
1844
            check_marker(s->avctx, gb, "after height");
1845 1846
            if (width && height &&  /* they should be non zero but who knows */
                !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
1847 1848 1849
                if (s->width && s->height &&
                    (s->width != width || s->height != height))
                    s->context_reinit = 1;
1850
                s->width  = width;
1851 1852 1853 1854
                s->height = height;
            }
        }

1855 1856 1857 1858 1859
        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 */
1860
                   "MPEG-4 OBMC not supported (very likely buggy encoder)\n");
1861
        if (vo_ver_id == 1)
1862
            ctx->vol_sprite_usage = get_bits1(gb);    /* vol_sprite_usage */
1863
        else
1864
            ctx->vol_sprite_usage = get_bits(gb, 2);  /* vol_sprite_usage */
1865

1866
        if (ctx->vol_sprite_usage == STATIC_SPRITE)
1867
            av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
1868 1869 1870
        if (ctx->vol_sprite_usage == STATIC_SPRITE ||
            ctx->vol_sprite_usage == GMC_SPRITE) {
            if (ctx->vol_sprite_usage == STATIC_SPRITE) {
1871
                skip_bits(gb, 13); // sprite_width
1872
                check_marker(s->avctx, gb, "after sprite_width");
1873
                skip_bits(gb, 13); // sprite_height
1874
                check_marker(s->avctx, gb, "after sprite_height");
1875
                skip_bits(gb, 13); // sprite_left
1876
                check_marker(s->avctx, gb, "after sprite_left");
1877
                skip_bits(gb, 13); // sprite_top
1878
                check_marker(s->avctx, gb, "after sprite_top");
1879
            }
1880 1881
            ctx->num_sprite_warping_points = get_bits(gb, 6);
            if (ctx->num_sprite_warping_points > 3) {
1882 1883
                av_log(s->avctx, AV_LOG_ERROR,
                       "%d sprite_warping_points\n",
1884 1885
                       ctx->num_sprite_warping_points);
                ctx->num_sprite_warping_points = 0;
1886
                return AVERROR_INVALIDDATA;
1887
            }
1888
            s->sprite_warping_accuracy  = get_bits(gb, 2);
1889
            ctx->sprite_brightness_change = get_bits1(gb);
1890
            if (ctx->vol_sprite_usage == STATIC_SPRITE)
1891
                skip_bits1(gb); // low_latency_sprite
1892 1893 1894
        }
        // FIXME sadct disable bit if verid!=1 && shape not rect

1895 1896 1897 1898 1899 1900 1901
        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);
1902
            if (s->quant_precision<3 || s->quant_precision>9) {
1903 1904
                s->quant_precision = 5;
            }
1905 1906 1907 1908 1909 1910
        } else {
            s->quant_precision = 5;
        }

        // FIXME a bunch of grayscale shape things

1911
        if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
1912 1913 1914
            int i, v;

            /* load default matrixes */
1915
            for (i = 0; i < 64; i++) {
1916
                int j = s->idsp.idct_permutation[i];
1917 1918 1919 1920 1921 1922 1923
                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;
1924 1925 1926
            }

            /* load custom intra matrix */
1927 1928 1929
            if (get_bits1(gb)) {
                int last = 0;
                for (i = 0; i < 64; i++) {
1930
                    int j;
1931 1932 1933 1934
                    if (get_bits_left(gb) < 8) {
                        av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
                        return AVERROR_INVALIDDATA;
                    }
1935 1936 1937 1938 1939
                    v = get_bits(gb, 8);
                    if (v == 0)
                        break;

                    last = v;
1940
                    j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1941 1942
                    s->intra_matrix[j]        = last;
                    s->chroma_intra_matrix[j] = last;
1943 1944 1945
                }

                /* replicate last value */
1946
                for (; i < 64; i++) {
1947
                    int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1948 1949
                    s->intra_matrix[j]        = last;
                    s->chroma_intra_matrix[j] = last;
1950 1951 1952 1953
                }
            }

            /* load custom non intra matrix */
1954 1955 1956
            if (get_bits1(gb)) {
                int last = 0;
                for (i = 0; i < 64; i++) {
1957
                    int j;
1958 1959 1960 1961
                    if (get_bits_left(gb) < 8) {
                        av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
                        return AVERROR_INVALIDDATA;
                    }
1962 1963 1964 1965 1966
                    v = get_bits(gb, 8);
                    if (v == 0)
                        break;

                    last = v;
1967
                    j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1968 1969
                    s->inter_matrix[j]        = v;
                    s->chroma_inter_matrix[j] = v;
1970 1971 1972
                }

                /* replicate last value */
1973
                for (; i < 64; i++) {
1974
                    int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1975 1976
                    s->inter_matrix[j]        = last;
                    s->chroma_inter_matrix[j] = last;
1977 1978 1979 1980 1981 1982
                }
            }

            // FIXME a bunch of grayscale shape things
        }

1983 1984 1985 1986 1987
        if (vo_ver_id != 1)
            s->quarter_sample = get_bits1(gb);
        else
            s->quarter_sample = 0;

1988 1989 1990 1991 1992
        if (get_bits_left(gb) < 4) {
            av_log(s->avctx, AV_LOG_ERROR, "VOL Header truncated\n");
            return AVERROR_INVALIDDATA;
        }

1993 1994 1995 1996 1997
        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)) {
1998 1999 2000 2001 2002
                    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 */
2003
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* upsampling */
2004
                }
2005
                if (!get_bits1(gb)) {
2006 2007 2008 2009
                    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 */
2010
                }
2011
                if (!check_marker(s->avctx, gb, "in complexity estimation part 1")) {
2012 2013 2014
                    skip_bits_long(gb, pos - get_bits_count(gb));
                    goto no_cplx_est;
                }
2015
                if (!get_bits1(gb)) {
2016 2017 2018 2019
                    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 */
2020
                }
2021
                if (!get_bits1(gb)) {
2022 2023 2024 2025 2026 2027
                    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 */
2028
                }
2029
                if (!check_marker(s->avctx, gb, "in complexity estimation part 2")) {
2030 2031 2032
                    skip_bits_long(gb, pos - get_bits_count(gb));
                    goto no_cplx_est;
                }
2033
                if (estimation_method == 1) {
2034 2035
                    ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* sadct */
                    ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* qpel */
2036
                }
2037 2038 2039 2040 2041 2042
            } else
                av_log(s->avctx, AV_LOG_ERROR,
                       "Invalid Complexity estimation method %d\n",
                       estimation_method);
        } else {

2043
no_cplx_est:
2044 2045 2046
            ctx->cplx_estimation_trash_i =
            ctx->cplx_estimation_trash_p =
            ctx->cplx_estimation_trash_b = 0;
2047 2048
        }

2049
        ctx->resync_marker = !get_bits1(gb); /* resync_marker_disabled */
2050

2051 2052
        s->data_partitioning = get_bits1(gb);
        if (s->data_partitioning)
2053
            ctx->rvlc = get_bits1(gb);
2054

2055
        if (vo_ver_id != 1) {
2056 2057
            ctx->new_pred = get_bits1(gb);
            if (ctx->new_pred) {
2058 2059
                av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
                skip_bits(gb, 2); /* requested upstream message type */
2060
                skip_bits1(gb);   /* newpred segment type */
2061
            }
2062
            if (get_bits1(gb)) // reduced_res_vop
2063 2064 2065
                av_log(s->avctx, AV_LOG_ERROR,
                       "reduced resolution VOP not supported\n");
        } else {
2066
            ctx->new_pred = 0;
2067 2068
        }

2069
        ctx->scalability = get_bits1(gb);
2070

2071
        if (ctx->scalability) {
2072
            GetBitContext bak = *gb;
2073 2074 2075 2076 2077
            int h_sampling_factor_n;
            int h_sampling_factor_m;
            int v_sampling_factor_n;
            int v_sampling_factor_m;

2078
            skip_bits1(gb);    // hierarchy_type
Mans Rullgard's avatar
Mans Rullgard committed
2079 2080
            skip_bits(gb, 4);  /* ref_layer_id */
            skip_bits1(gb);    /* ref_layer_sampling_dir */
2081 2082 2083 2084
            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);
2085
            ctx->enhancement_type = get_bits1(gb);
2086 2087 2088

            if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
                v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2089 2090
                /* illegal scalability header (VERY broken encoder),
                 * trying to workaround */
2091
                ctx->scalability = 0;
2092 2093
                *gb            = bak;
            } else
2094 2095 2096 2097 2098
                av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");

            // bin shape stuff FIXME
        }
    }
2099

2100
    if (s->avctx->debug&FF_DEBUG_PICT_INFO) {
2101
        av_log(s->avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d, low_delay:%d  %s%s%s%s\n",
2102
               s->avctx->framerate.den, s->avctx->framerate.num,
2103
               ctx->time_increment_bits,
2104 2105
               s->quant_precision,
               s->progressive_sequence,
2106
               s->low_delay,
2107
               ctx->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "",
2108
               s->data_partitioning ? "partition " : "", ctx->rvlc ? "rvlc " : ""
2109 2110 2111
        );
    }

2112 2113 2114 2115
    return 0;
}

/**
2116
 * Decode the user data stuff in the header.
2117 2118
 * Also initializes divx/xvid/lavc_version/build.
 */
2119
static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
2120
{
2121
    MpegEncContext *s = &ctx->m;
2122 2123 2124 2125 2126 2127
    char buf[256];
    int i;
    int e;
    int ver = 0, build = 0, ver2 = 0, ver3 = 0;
    char last;

2128 2129 2130 2131
    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);
2132
    }
2133
    buf[i] = 0;
2134 2135

    /* divx detection */
2136 2137 2138 2139
    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) {
2140 2141
        ctx->divx_version = ver;
        ctx->divx_build   = build;
2142
        s->divx_packed  = e == 3 && last == 'p';
2143 2144
    }

2145
    /* libavcodec detection */
2146 2147 2148 2149 2150 2151 2152
    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;
2153
    }
2154 2155
    if (e != 4) {
        if (strcmp(buf, "ffmpeg") == 0)
2156
            ctx->lavc_build = 4600;
2157
    }
2158
    if (e == 4)
2159
        ctx->lavc_build = build;
2160 2161

    /* Xvid detection */
2162 2163
    e = sscanf(buf, "XviD%d", &build);
    if (e == 1)
2164
        ctx->xvid_build = build;
2165 2166 2167 2168

    return 0;
}

2169 2170 2171 2172 2173
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
{
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext *s = &ctx->m;

2174
    if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
2175
        if (s->codec_tag        == AV_RL32("XVID") ||
2176 2177 2178 2179
            s->codec_tag        == AV_RL32("XVIX") ||
            s->codec_tag        == AV_RL32("RMP4") ||
            s->codec_tag        == AV_RL32("ZMP4") ||
            s->codec_tag        == AV_RL32("SIPP"))
2180
            ctx->xvid_build = 0;
2181 2182
    }

2183
    if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
2184
        if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
2185
            ctx->vol_control_parameters == 0)
2186
            ctx->divx_version = 400;  // divx 4
2187

2188 2189 2190
    if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
        ctx->divx_version =
        ctx->divx_build   = -1;
2191 2192 2193 2194 2195 2196 2197 2198 2199
    }

    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;

2200
        if (ctx->divx_version >= 500 && ctx->divx_build < 1814)
2201 2202
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA;

2203
        if (ctx->divx_version > 502 && ctx->divx_build < 1814)
2204 2205
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA2;

2206
        if (ctx->xvid_build <= 3U)
2207 2208
            s->padding_bug_score = 256 * 256 * 256 * 64;

2209
        if (ctx->xvid_build <= 1U)
2210 2211
            s->workaround_bugs |= FF_BUG_QPEL_CHROMA;

2212
        if (ctx->xvid_build <= 12U)
2213 2214
            s->workaround_bugs |= FF_BUG_EDGE;

2215
        if (ctx->xvid_build <= 32U)
2216 2217 2218
            s->workaround_bugs |= FF_BUG_DC_CLIP;

#define SET_QPEL_FUNC(postfix1, postfix2)                           \
2219 2220 2221
    s->qdsp.put_        ## postfix1 = ff_put_        ## postfix2;   \
    s->qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;   \
    s->qdsp.avg_        ## postfix1 = ff_avg_        ## postfix2;
2222

2223
        if (ctx->lavc_build < 4653U)
2224 2225
            s->workaround_bugs |= FF_BUG_STD_QPEL;

2226
        if (ctx->lavc_build < 4655U)
2227 2228
            s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;

2229
        if (ctx->lavc_build < 4670U)
2230 2231
            s->workaround_bugs |= FF_BUG_EDGE;

2232
        if (ctx->lavc_build <= 4712U)
2233 2234
            s->workaround_bugs |= FF_BUG_DC_CLIP;

2235 2236 2237 2238 2239 2240 2241
        if ((ctx->lavc_build&0xFF) >= 100) {
            if (ctx->lavc_build > 3621476 && ctx->lavc_build < 3752552 &&
               (ctx->lavc_build < 3752037 || ctx->lavc_build > 3752191) // 3.2.1+
            )
                s->workaround_bugs |= FF_BUG_IEDGE;
        }

2242
        if (ctx->divx_version >= 0)
2243
            s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
2244
        if (ctx->divx_version == 501 && ctx->divx_build == 20020416)
2245 2246
            s->padding_bug_score = 256 * 256 * 256 * 64;

2247
        if (ctx->divx_version < 500U)
2248 2249
            s->workaround_bugs |= FF_BUG_EDGE;

2250
        if (ctx->divx_version >= 0)
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
            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",
2273 2274
               s->workaround_bugs, ctx->lavc_build, ctx->xvid_build,
               ctx->divx_version, ctx->divx_build, s->divx_packed ? "p" : "");
2275

2276 2277
    if (CONFIG_MPEG4_DECODER && ctx->xvid_build >= 0 &&
        s->codec_id == AV_CODEC_ID_MPEG4 &&
2278
        avctx->idct_algo == FF_IDCT_AUTO) {
2279
        avctx->idct_algo = FF_IDCT_XVID;
2280
        ff_mpv_idct_init(s);
2281 2282
        return 1;
    }
2283

2284 2285 2286
    return 0;
}

2287
static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2288
{
2289
    MpegEncContext *s = &ctx->m;
2290
    int time_incr, time_increment;
2291
    int64_t pts;
2292

2293
    s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;        /* pict type: I = 0 , P = 1 */
2294
    if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
2295
        ctx->vol_control_parameters == 0 && !(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) {
2296
        av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
2297
        s->low_delay = 0;
2298 2299
    }

2300 2301 2302
    s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
    if (s->partitioned_frame)
        s->decode_mb = mpeg4_decode_partitioned_mb;
2303
    else
2304
        s->decode_mb = mpeg4_decode_mb;
2305

2306
    time_incr = 0;
2307 2308 2309
    while (get_bits1(gb) != 0)
        time_incr++;

2310
    check_marker(s->avctx, gb, "before time_increment");
2311

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

2317 2318 2319
        for (ctx->time_increment_bits = 1;
             ctx->time_increment_bits < 16;
             ctx->time_increment_bits++) {
2320 2321
            if (s->pict_type == AV_PICTURE_TYPE_P ||
                (s->pict_type == AV_PICTURE_TYPE_S &&
2322
                 ctx->vol_sprite_usage == GMC_SPRITE)) {
2323
                if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
2324
                    break;
2325
            } else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
2326
                break;
2327 2328
        }

2329
        av_log(s->avctx, AV_LOG_WARNING,
2330
               "time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits);
2331 2332 2333
        if (s->avctx->framerate.num && 4*s->avctx->framerate.num < 1<<ctx->time_increment_bits) {
            s->avctx->framerate.num = 1<<ctx->time_increment_bits;
            s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
2334
        }
2335 2336
    }

2337 2338 2339
    if (IS_3IV1)
        time_increment = get_bits1(gb);        // FIXME investigate further
    else
2340
        time_increment = get_bits(gb, ctx->time_increment_bits);
2341 2342 2343 2344

    if (s->pict_type != AV_PICTURE_TYPE_B) {
        s->last_time_base = s->time_base;
        s->time_base     += time_incr;
2345
        s->time = s->time_base * s->avctx->framerate.num + time_increment;
2346 2347
        if (s->workaround_bugs & FF_BUG_UMP4) {
            if (s->time < s->last_non_b_time) {
2348 2349 2350
                /* header is not mpeg-4-compatible, broken encoder,
                 * trying to workaround */
                s->time_base++;
2351
                s->time += s->avctx->framerate.num;
2352 2353
            }
        }
2354 2355 2356
        s->pp_time         = s->time - s->last_non_b_time;
        s->last_non_b_time = s->time;
    } else {
2357
        s->time    = (s->last_time_base + time_incr) * s->avctx->framerate.num + time_increment;
2358 2359 2360 2361
        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) {
2362
            /* messed up order, maybe after seeking? skipping current B-frame */
2363 2364 2365 2366
            return FRAME_SKIPPED;
        }
        ff_mpeg4_init_direct_mv(s);

2367 2368 2369 2370 2371 2372 2373 2374
        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;
2375 2376 2377 2378
        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)
2379 2380 2381 2382
                return FRAME_SKIPPED;
        }
    }

2383 2384
    if (s->avctx->framerate.den)
        pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
2385
    else
2386
        pts = AV_NOPTS_VALUE;
2387
    ff_dlog(s->avctx, "MPEG4 PTS: %"PRId64"\n", pts);
2388

2389
    check_marker(s->avctx, gb, "before vop_coded");
2390 2391

    /* vop coded */
2392 2393
    if (get_bits1(gb) != 1) {
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2394 2395 2396
            av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
        return FRAME_SKIPPED;
    }
2397
    if (ctx->new_pred)
2398
        decode_new_pred(ctx, gb);
2399

2400
    if (ctx->shape != BIN_ONLY_SHAPE &&
2401 2402
                    (s->pict_type == AV_PICTURE_TYPE_P ||
                     (s->pict_type == AV_PICTURE_TYPE_S &&
2403
                      ctx->vol_sprite_usage == GMC_SPRITE))) {
2404 2405 2406 2407 2408
        /* rounding type for motion estimation */
        s->no_rounding = get_bits1(gb);
    } else {
        s->no_rounding = 0;
    }
2409 2410
    // FIXME reduced res stuff

2411
    if (ctx->shape != RECT_SHAPE) {
2412
        if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
2413
            skip_bits(gb, 13);  /* width */
2414
            check_marker(s->avctx, gb, "after width");
2415
            skip_bits(gb, 13);  /* height */
2416
            check_marker(s->avctx, gb, "after height");
2417
            skip_bits(gb, 13);  /* hor_spat_ref */
2418
            check_marker(s->avctx, gb, "after hor_spat_ref");
2419 2420 2421 2422 2423 2424 2425 2426 2427 2428
            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

2429
    if (ctx->shape != BIN_ONLY_SHAPE) {
2430
        skip_bits_long(gb, ctx->cplx_estimation_trash_i);
2431
        if (s->pict_type != AV_PICTURE_TYPE_I)
2432
            skip_bits_long(gb, ctx->cplx_estimation_trash_p);
2433
        if (s->pict_type == AV_PICTURE_TYPE_B)
2434
            skip_bits_long(gb, ctx->cplx_estimation_trash_b);
2435

2436 2437
        if (get_bits_left(gb) < 3) {
            av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
2438
            return AVERROR_INVALIDDATA;
2439
        }
2440
        ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
2441 2442 2443 2444 2445 2446 2447 2448
        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) {
2449 2450 2451 2452
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
2453
    } else {
2454 2455 2456 2457
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
2458 2459 2460
    }

    if (s->pict_type == AV_PICTURE_TYPE_S &&
2461 2462
        (ctx->vol_sprite_usage == STATIC_SPRITE ||
         ctx->vol_sprite_usage == GMC_SPRITE)) {
2463
        if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
2464
            return AVERROR_INVALIDDATA;
2465
        if (ctx->sprite_brightness_change)
2466 2467
            av_log(s->avctx, AV_LOG_ERROR,
                   "sprite_brightness_change not supported\n");
2468
        if (ctx->vol_sprite_usage == STATIC_SPRITE)
2469 2470 2471
            av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
    }

2472
    if (ctx->shape != BIN_ONLY_SHAPE) {
2473 2474 2475
        s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
        if (s->qscale == 0) {
            av_log(s->avctx, AV_LOG_ERROR,
2476
                   "Error, header damaged or not MPEG-4 header (qscale=0)\n");
2477
            return AVERROR_INVALIDDATA;  // makes no sense to continue, as there is nothing left from the image then
2478 2479 2480 2481 2482 2483
        }

        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,
2484
                       "Error, header damaged or not MPEG-4 header (f_code=0)\n");
2485
                s->f_code = 1;
2486
                return AVERROR_INVALIDDATA;  // makes no sense to continue, as there is nothing left from the image then
2487 2488 2489 2490 2491 2492
            }
        } else
            s->f_code = 1;

        if (s->pict_type == AV_PICTURE_TYPE_B) {
            s->b_code = get_bits(gb, 3);
2493 2494 2495 2496
            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;
2497
                return AVERROR_INVALIDDATA; // makes no sense to continue, as the MV decoding will break very quickly
2498
            }
2499 2500 2501 2502 2503
        } else
            s->b_code = 1;

        if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
            av_log(s->avctx, AV_LOG_DEBUG,
2504
                   "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",
2505 2506
                   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")),
2507
                   gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
2508
                   s->top_field_first, s->quarter_sample ? "q" : "h",
2509
                   s->data_partitioning, ctx->resync_marker,
2510
                   ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
2511
                   1 - s->no_rounding, s->vo_type,
2512
                   ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
2513
                   ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
2514
                   ctx->cplx_estimation_trash_b,
2515 2516 2517
                   s->time,
                   time_increment
                  );
2518 2519
        }

2520
        if (!ctx->scalability) {
2521
            if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
2522 2523
                skip_bits1(gb);  // vop shape coding type
        } else {
2524
            if (ctx->enhancement_type) {
2525 2526 2527 2528 2529 2530 2531 2532 2533
                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
2534
     * (divx4/xvid/opendivx). Note we cannot detect divx5 without B-frames
2535
     * easily (although it's buggy too) */
2536
    if (s->vo_type == 0 && ctx->vol_control_parameters == 0 &&
2537
        ctx->divx_version == -1 && s->picture_number == 0) {
2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553
        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;
2554 2555 2556
}

/**
2557
 * Decode MPEG-4 headers.
2558 2559 2560 2561
 * @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
 */
2562
int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2563
{
2564
    MpegEncContext *s = &ctx->m;
2565
    unsigned startcode, v;
2566
    int ret;
2567 2568 2569 2570

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

2571
    if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
2572
        skip_bits(gb, 24);
2573
        if (get_bits(gb, 8) == 0xF0)
2574 2575 2576 2577
            goto end;
    }

    startcode = 0xff;
2578 2579 2580
    for (;;) {
        if (get_bits_count(gb) >= gb->size_in_bits) {
            if (gb->size_in_bits == 8 &&
2581
                (ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
2582
                av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
2583 2584 2585
                return FRAME_SKIPPED;  // divx bug
            } else
                return -1;  // end of stream
2586 2587 2588 2589 2590 2591
        }

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

2592 2593
        if ((startcode & 0xFFFFFF00) != 0x100)
            continue;  // no startcode
2594

2595
        if (s->avctx->debug & FF_DEBUG_STARTCODE) {
2596
            av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
            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");
2651 2652 2653
            av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
        }

2654
        if (startcode >= 0x120 && startcode <= 0x12F) {
2655 2656
            if ((ret = decode_vol_header(ctx, gb)) < 0)
                return ret;
2657
        } else if (startcode == USER_DATA_STARTCODE) {
2658
            decode_user_data(ctx, gb);
2659
        } else if (startcode == GOP_STARTCODE) {
2660
            mpeg4_decode_gop_header(s, gb);
2661
        } else if (startcode == VOS_STARTCODE) {
2662
            mpeg4_decode_profile_level(s, gb);
2663
        } else if (startcode == VOP_STARTCODE) {
2664 2665 2666 2667 2668 2669
            break;
        }

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

2671
end:
2672
    if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2673 2674 2675
        s->low_delay = 1;
    s->avctx->has_b_frames = !s->low_delay;

2676
    return decode_vop_header(ctx, gb);
2677 2678
}

2679
av_cold void ff_mpeg4videodec_static_init(void) {
2680 2681 2682
    static int done = 0;

    if (!done) {
2683 2684 2685
        ff_rl_init(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
        ff_rl_init(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
        ff_rl_init(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
2686
        INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
2687 2688
        INIT_VLC_RL(ff_rvlc_rl_inter, 1072);
        INIT_VLC_RL(ff_rvlc_rl_intra, 1072);
2689
        INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2690 2691
                        &ff_mpeg4_DCtab_lum[0][1], 2, 1,
                        &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
2692
        INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2693 2694
                        &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
                        &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
2695
        INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2696 2697
                        &ff_sprite_trajectory_tab[0][1], 4, 2,
                        &ff_sprite_trajectory_tab[0][0], 4, 2, 128);
2698
        INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2699 2700
                        &ff_mb_type_b_tab[0][1], 2, 1,
                        &ff_mb_type_b_tab[0][0], 2, 1, 16);
2701
        done = 1;
2702
    }
2703 2704
}

2705 2706 2707 2708 2709
int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
{
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext    *s = &ctx->m;

2710 2711 2712
    /* 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 */
2713
    if (s->divx_packed) {
2714
        int current_pos     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);
2715 2716
        int startcode_found = 0;

2717 2718
        if (buf_size - current_pos > 7) {

2719
            int i;
2720 2721
            for (i = current_pos; i < buf_size - 4; i++)

2722 2723 2724 2725
                if (buf[i]     == 0 &&
                    buf[i + 1] == 0 &&
                    buf[i + 2] == 1 &&
                    buf[i + 3] == 0xB6) {
2726
                    startcode_found = !(buf[i + 4] & 0x40);
2727 2728 2729 2730 2731
                    break;
                }
        }

        if (startcode_found) {
2732 2733 2734
            if (!ctx->showed_packed_warning) {
                av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and "
                       "wasteful way to store B-frames ('packed B-frames'). "
2735
                       "Consider using the mpeg4_unpack_bframes bitstream filter without encoding but stream copy to fix it.\n");
2736 2737
                ctx->showed_packed_warning = 1;
            }
2738
            av_fast_padded_malloc(&s->bitstream_buffer,
2739
                           &s->allocated_bitstream_buffer_size,
2740
                           buf_size - current_pos);
2741 2742
            if (!s->bitstream_buffer) {
                s->bitstream_buffer_size = 0;
2743
                return AVERROR(ENOMEM);
2744
            }
2745 2746 2747 2748 2749 2750 2751 2752 2753
            memcpy(s->bitstream_buffer, buf + current_pos,
                   buf_size - current_pos);
            s->bitstream_buffer_size = buf_size - current_pos;
        }
    }

    return 0;
}

2754
#if HAVE_THREADS
2755 2756 2757 2758 2759
static int mpeg4_update_thread_context(AVCodecContext *dst,
                                       const AVCodecContext *src)
{
    Mpeg4DecContext *s = dst->priv_data;
    const Mpeg4DecContext *s1 = src->priv_data;
2760
    int init = s->m.context_initialized;
2761 2762 2763 2764 2765 2766

    int ret = ff_mpeg_update_thread_context(dst, src);

    if (ret < 0)
        return ret;

2767
    memcpy(((uint8_t*)s) + sizeof(MpegEncContext), ((uint8_t*)s1) + sizeof(MpegEncContext), sizeof(Mpeg4DecContext) - sizeof(MpegEncContext));
2768

2769
    if (CONFIG_MPEG4_DECODER && !init && s1->xvid_build >= 0)
2770
        ff_xvid_idct_init(&s->m.idsp, dst);
2771

2772 2773
    return 0;
}
2774
#endif
2775

2776 2777
static av_cold int decode_init(AVCodecContext *avctx)
{
2778 2779
    Mpeg4DecContext *ctx = avctx->priv_data;
    MpegEncContext *s = &ctx->m;
2780 2781
    int ret;

2782 2783 2784 2785
    ctx->divx_version =
    ctx->divx_build   =
    ctx->xvid_build   =
    ctx->lavc_build   = -1;
2786

2787
    if ((ret = ff_h263_decode_init(avctx)) < 0)
2788 2789 2790
        return ret;

    ff_mpeg4videodec_static_init();
2791 2792

    s->h263_pred = 1;
2793
    s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
2794
    s->decode_mb = mpeg4_decode_mb;
2795
    ctx->time_increment_bits = 4; /* default value for broken headers */
2796

2797
    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
2798 2799
    avctx->internal->allocate_progress = 1;

2800 2801 2802
    return 0;
}

2803
static const AVOption mpeg4_options[] = {
2804 2805
    {"quarter_sample", "1/4 subpel MC", offsetof(MpegEncContext, quarter_sample), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
    {"divx_packed", "divx style packed b frames", offsetof(MpegEncContext, divx_packed), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
2806 2807 2808 2809 2810 2811 2812 2813 2814 2815
    {NULL}
};

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

2816
AVCodec ff_mpeg4_decoder = {
2817
    .name                  = "mpeg4",
2818
    .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
2819
    .type                  = AVMEDIA_TYPE_VIDEO,
2820
    .id                    = AV_CODEC_ID_MPEG4,
2821
    .priv_data_size        = sizeof(Mpeg4DecContext),
2822 2823 2824
    .init                  = decode_init,
    .close                 = ff_h263_decode_end,
    .decode                = ff_h263_decode_frame,
2825 2826 2827
    .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                             AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                             AV_CODEC_CAP_FRAME_THREADS,
2828
    .caps_internal         = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2829
    .flush                 = ff_mpeg_flush,
2830
    .max_lowres            = 3,
2831
    .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
2832
    .profiles              = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles),
2833
    .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg4_update_thread_context),
2834
    .priv_class = &mpeg4_class,
2835 2836
};

2837

2838
#if CONFIG_MPEG4_VDPAU_DECODER && FF_API_VDPAU
2839 2840 2841 2842 2843 2844 2845
static const AVClass mpeg4_vdpau_class = {
    "MPEG4 Video VDPAU Decoder",
    av_default_item_name,
    mpeg4_options,
    LIBAVUTIL_VERSION_INT,
};

2846 2847
AVCodec ff_mpeg4_vdpau_decoder = {
    .name           = "mpeg4_vdpau",
2848
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
2849 2850
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_MPEG4,
2851
    .priv_data_size = sizeof(Mpeg4DecContext),
2852 2853 2854
    .init           = decode_init,
    .close          = ff_h263_decode_end,
    .decode         = ff_h263_decode_frame,
2855 2856
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                      AV_CODEC_CAP_HWACCEL_VDPAU,
2857
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_MPEG4,
2858 2859 2860 2861
                                                  AV_PIX_FMT_NONE },
    .priv_class     = &mpeg4_vdpau_class,
};
#endif