git.sesse.net Git - ffmpeg/blob - libavcodec/mpeg4videodec.c

   1 /*
   2  * MPEG-4 decoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #define UNCHECKED_BITSTREAM_READER 1
  24
  25 #include "libavutil/internal.h"
  26 #include "libavutil/opt.h"
  27 #include "libavutil/pixdesc.h"
  28 #include "libavutil/thread.h"
  29 #include "error_resilience.h"
  30 #include "hwconfig.h"
  31 #include "idctdsp.h"
  32 #include "internal.h"
  33 #include "mpegutils.h"
  34 #include "mpegvideo.h"
  35 #include "mpegvideodata.h"
  36 #include "mpeg4video.h"
  37 #include "h263.h"
  38 #include "profiles.h"
  39 #include "thread.h"
  40 #include "xvididct.h"
  41 #include "unary.h"
  42
  43 /* The defines below define the number of bits that are read at once for
  44  * reading vlc values. Changing these may improve speed and data cache needs
  45  * be aware though that decreasing them may need the number of stages that is
  46  * passed to get_vlc* to be increased. */
  47 #define SPRITE_TRAJ_VLC_BITS 6
  48 #define DC_VLC_BITS 9
  49 #define MB_TYPE_B_VLC_BITS 4
  50 #define STUDIO_INTRA_BITS 9
  51
  52 static VLC dc_lum, dc_chrom;
  53 static VLC sprite_trajectory;
  54 static VLC mb_type_b_vlc;
  55 static VLC studio_intra_tab[12];
  56 static VLC studio_luma_dc;
  57 static VLC studio_chroma_dc;
  58
  59 static const int mb_type_b_map[4] = {
  60     MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
  61     MB_TYPE_L0L1    | MB_TYPE_16x16,
  62     MB_TYPE_L1      | MB_TYPE_16x16,
  63     MB_TYPE_L0      | MB_TYPE_16x16,
  64 };
  65
  66 /**
  67  * Predict the ac.
  68  * @param n block index (0-3 are luma, 4-5 are chroma)
  69  * @param dir the ac prediction direction
  70  */
  71 void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
  72 {
  73     int i;
  74     int16_t *ac_val, *ac_val1;
  75     int8_t *const qscale_table = s->current_picture.qscale_table;
  76
  77     /* find prediction */
  78     ac_val  = &s->ac_val[0][0][0] + s->block_index[n] * 16;
  79     ac_val1 = ac_val;
  80     if (s->ac_pred) {
  81         if (dir == 0) {
  82             const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride;
  83             /* left prediction */
  84             ac_val -= 16;
  85
  86             if (s->mb_x == 0 || s->qscale == qscale_table[xy] ||
  87                 n == 1 || n == 3) {
  88                 /* same qscale */
  89                 for (i = 1; i < 8; i++)
  90                     block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
  91             } else {
  92                 /* different qscale, we must rescale */
  93                 for (i = 1; i < 8; i++)
  94                     block[s->idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
  95             }
  96         } else {
  97             const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
  98             /* top prediction */
  99             ac_val -= 16 * s->block_wrap[n];
 100
 101             if (s->mb_y == 0 || s->qscale == qscale_table[xy] ||
 102                 n == 2 || n == 3) {
 103                 /* same qscale */
 104                 for (i = 1; i < 8; i++)
 105                     block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
 106             } else {
 107                 /* different qscale, we must rescale */
 108                 for (i = 1; i < 8; i++)
 109                     block[s->idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
 110             }
 111         }
 112     }
 113     /* left copy */
 114     for (i = 1; i < 8; i++)
 115         ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
 116
 117     /* top copy */
 118     for (i = 1; i < 8; i++)
 119         ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
 120 }
 121
 122 /**
 123  * check if the next stuff is a resync marker or the end.
 124  * @return 0 if not
 125  */
 126 static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
 127 {
 128     MpegEncContext *s = &ctx->m;
 129     int bits_count = get_bits_count(&s->gb);
 130     int v          = show_bits(&s->gb, 16);
 131
 132     if (s->workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker)
 133         return 0;
 134
 135     while (v <= 0xFF) {
 136         if (s->pict_type == AV_PICTURE_TYPE_B ||
 137             (v >> (8 - s->pict_type) != 1) || s->partitioned_frame)
 138             break;
 139         skip_bits(&s->gb, 8 + s->pict_type);
 140         bits_count += 8 + s->pict_type;
 141         v = show_bits(&s->gb, 16);
 142     }
 143
 144     if (bits_count + 8 >= s->gb.size_in_bits) {
 145         v >>= 8;
 146         v  |= 0x7F >> (7 - (bits_count & 7));
 147
 148         if (v == 0x7F)
 149             return s->mb_num;
 150     } else {
 151         if (v == ff_mpeg4_resync_prefix[bits_count & 7]) {
 152             int len, mb_num;
 153             int mb_num_bits = av_log2(s->mb_num - 1) + 1;
 154             GetBitContext gb = s->gb;
 155
 156             skip_bits(&s->gb, 1);
 157             align_get_bits(&s->gb);
 158
 159             for (len = 0; len < 32; len++)
 160                 if (get_bits1(&s->gb))
 161                     break;
 162
 163             mb_num = get_bits(&s->gb, mb_num_bits);
 164             if (!mb_num || mb_num > s->mb_num || get_bits_count(&s->gb)+6 > s->gb.size_in_bits)
 165                 mb_num= -1;
 166
 167             s->gb = gb;
 168
 169             if (len >= ff_mpeg4_get_video_packet_prefix_length(s))
 170                 return mb_num;
 171         }
 172     }
 173     return 0;
 174 }
 175
 176 static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
 177 {
 178     MpegEncContext *s = &ctx->m;
 179     int a     = 2 << s->sprite_warping_accuracy;
 180     int rho   = 3  - s->sprite_warping_accuracy;
 181     int r     = 16 / a;
 182     int alpha = 1;
 183     int beta  = 0;
 184     int w     = s->width;
 185     int h     = s->height;
 186     int min_ab, i, w2, h2, w3, h3;
 187     int sprite_ref[4][2];
 188     int virtual_ref[2][2];
 189     int64_t sprite_offset[2][2];
 190     int64_t sprite_delta[2][2];
 191
 192     // only true for rectangle shapes
 193     const int vop_ref[4][2] = { { 0, 0 },         { s->width, 0 },
 194                                 { 0, s->height }, { s->width, s->height } };
 195     int d[4][2]             = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
 196
 197     if (w <= 0 || h <= 0)
 198         return AVERROR_INVALIDDATA;
 199
 200     /* the decoder was not properly initialized and we cannot continue */
 201     if (sprite_trajectory.table == NULL)
 202         return AVERROR_INVALIDDATA;
 203
 204     for (i = 0; i < ctx->num_sprite_warping_points; i++) {
 205         int length;
 206         int x = 0, y = 0;
 207
 208         length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 2);
 209         if (length > 0)
 210             x = get_xbits(gb, length);
 211
 212         if (!(ctx->divx_version == 500 && ctx->divx_build == 413))
 213             check_marker(s->avctx, gb, "before sprite_trajectory");
 214
 215         length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 2);
 216         if (length > 0)
 217             y = get_xbits(gb, length);
 218
 219         check_marker(s->avctx, gb, "after sprite_trajectory");
 220         ctx->sprite_traj[i][0] = d[i][0] = x;
 221         ctx->sprite_traj[i][1] = d[i][1] = y;
 222     }
 223     for (; i < 4; i++)
 224         ctx->sprite_traj[i][0] = ctx->sprite_traj[i][1] = 0;
 225
 226     while ((1 << alpha) < w)
 227         alpha++;
 228     while ((1 << beta) < h)
 229         beta++;  /* typo in the MPEG-4 std for the definition of w' and h' */
 230     w2 = 1 << alpha;
 231     h2 = 1 << beta;
 232
 233     // Note, the 4th point isn't used for GMC
 234     if (ctx->divx_version == 500 && ctx->divx_build == 413) {
 235         sprite_ref[0][0] = a * vop_ref[0][0] + d[0][0];
 236         sprite_ref[0][1] = a * vop_ref[0][1] + d[0][1];
 237         sprite_ref[1][0] = a * vop_ref[1][0] + d[0][0] + d[1][0];
 238         sprite_ref[1][1] = a * vop_ref[1][1] + d[0][1] + d[1][1];
 239         sprite_ref[2][0] = a * vop_ref[2][0] + d[0][0] + d[2][0];
 240         sprite_ref[2][1] = a * vop_ref[2][1] + d[0][1] + d[2][1];
 241     } else {
 242         sprite_ref[0][0] = (a >> 1) * (2 * vop_ref[0][0] + d[0][0]);
 243         sprite_ref[0][1] = (a >> 1) * (2 * vop_ref[0][1] + d[0][1]);
 244         sprite_ref[1][0] = (a >> 1) * (2 * vop_ref[1][0] + d[0][0] + d[1][0]);
 245         sprite_ref[1][1] = (a >> 1) * (2 * vop_ref[1][1] + d[0][1] + d[1][1]);
 246         sprite_ref[2][0] = (a >> 1) * (2 * vop_ref[2][0] + d[0][0] + d[2][0]);
 247         sprite_ref[2][1] = (a >> 1) * (2 * vop_ref[2][1] + d[0][1] + d[2][1]);
 248     }
 249     /* sprite_ref[3][0] = (a >> 1) * (2 * vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
 250      * sprite_ref[3][1] = (a >> 1) * (2 * vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
 251
 252     /* This is mostly identical to the MPEG-4 std (and is totally unreadable
 253      * because of that...). Perhaps it should be reordered to be more readable.
 254      * The idea behind this virtual_ref mess is to be able to use shifts later
 255      * per pixel instead of divides so the distance between points is converted
 256      * from w&h based to w2&h2 based which are of the 2^x form. */
 257     virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +
 258                          ROUNDED_DIV(((w - w2) *
 259                                            (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
 260                                       w2 * (r * sprite_ref[1][0] - 16LL * vop_ref[1][0])), w);
 261     virtual_ref[0][1] = 16 * vop_ref[0][1] +
 262                         ROUNDED_DIV(((w - w2) *
 263                                           (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
 264                                      w2 * (r * sprite_ref[1][1] - 16LL * vop_ref[1][1])), w);
 265     virtual_ref[1][0] = 16 * vop_ref[0][0] +
 266                         ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
 267                                            h2 * (r * sprite_ref[2][0] - 16LL * vop_ref[2][0])), h);
 268     virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +
 269                         ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
 270                                            h2 * (r * sprite_ref[2][1] - 16LL * vop_ref[2][1])), h);
 271
 272     switch (ctx->num_sprite_warping_points) {
 273     case 0:
 274         sprite_offset[0][0]    =
 275         sprite_offset[0][1]    =
 276         sprite_offset[1][0]    =
 277         sprite_offset[1][1]    = 0;
 278         sprite_delta[0][0]     = a;
 279         sprite_delta[0][1]     =
 280         sprite_delta[1][0]     = 0;
 281         sprite_delta[1][1]     = a;
 282         ctx->sprite_shift[0]   =
 283         ctx->sprite_shift[1]   = 0;
 284         break;
 285     case 1:     // GMC only
 286         sprite_offset[0][0]    = sprite_ref[0][0] - a * vop_ref[0][0];
 287         sprite_offset[0][1]    = sprite_ref[0][1] - a * vop_ref[0][1];
 288         sprite_offset[1][0]    = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
 289                                  a * (vop_ref[0][0] / 2);
 290         sprite_offset[1][1]    = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
 291                                  a * (vop_ref[0][1] / 2);
 292         sprite_delta[0][0]     = a;
 293         sprite_delta[0][1]     =
 294         sprite_delta[1][0]     = 0;
 295         sprite_delta[1][1]     = a;
 296         ctx->sprite_shift[0]   =
 297         ctx->sprite_shift[1]   = 0;
 298         break;
 299     case 2:
 300         sprite_offset[0][0]    = ((int64_t)      sprite_ref[0][0] * (1 << alpha + rho)) +
 301                                  ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *
 302                                  ((int64_t)        -vop_ref[0][0]) +
 303                                  ((int64_t)  r * sprite_ref[0][1] - virtual_ref[0][1]) *
 304                                  ((int64_t)        -vop_ref[0][1]) + (1 << (alpha + rho - 1));
 305         sprite_offset[0][1]    = ((int64_t)      sprite_ref[0][1] * (1 << alpha + rho)) +
 306                                  ((int64_t) -r * sprite_ref[0][1] + virtual_ref[0][1]) *
 307                                  ((int64_t)        -vop_ref[0][0]) +
 308                                  ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *
 309                                  ((int64_t)        -vop_ref[0][1]) + (1 << (alpha + rho - 1));
 310         sprite_offset[1][0]    = (((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 311                                   ((int64_t)-2 *    vop_ref[0][0] + 1) +
 312                                   ((int64_t) r * sprite_ref[0][1] - virtual_ref[0][1]) *
 313                                   ((int64_t)-2 *    vop_ref[0][1] + 1) + 2 * w2 * r *
 314                                    (int64_t)     sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));
 315         sprite_offset[1][1]    = (((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) *
 316                                   ((int64_t)-2 *    vop_ref[0][0] + 1) +
 317                                   ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 318                                   ((int64_t)-2 *    vop_ref[0][1] + 1) + 2 * w2 * r *
 319                                   (int64_t)      sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));
 320         sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
 321         sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);
 322         sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);
 323         sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
 324
 325         ctx->sprite_shift[0]  = alpha + rho;
 326         ctx->sprite_shift[1]  = alpha + rho + 2;
 327         break;
 328     case 3:
 329         min_ab = FFMIN(alpha, beta);
 330         w3     = w2 >> min_ab;
 331         h3     = h2 >> min_ab;
 332         sprite_offset[0][0]    = ((int64_t)sprite_ref[0][0] * (1 << (alpha + beta + rho - min_ab))) +
 333                                  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-vop_ref[0][0]) +
 334                                  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-vop_ref[0][1]) +
 335                                  ((int64_t)1 << (alpha + beta + rho - min_ab - 1));
 336         sprite_offset[0][1]    = ((int64_t)sprite_ref[0][1] * (1 << (alpha + beta + rho - min_ab))) +
 337                                  ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-vop_ref[0][0]) +
 338                                  ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-vop_ref[0][1]) +
 339                                  ((int64_t)1 << (alpha + beta + rho - min_ab - 1));
 340         sprite_offset[1][0]    = ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-2 * vop_ref[0][0] + 1) +
 341                                  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-2 * vop_ref[0][1] + 1) +
 342                                   (int64_t)2 * w2 * h3 * r * sprite_ref[0][0] - 16 * w2 * h3 +
 343                                  ((int64_t)1 << (alpha + beta + rho - min_ab + 1));
 344         sprite_offset[1][1]    = ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-2 * vop_ref[0][0] + 1) +
 345                                  ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-2 * vop_ref[0][1] + 1) +
 346                                   (int64_t)2 * w2 * h3 * r * sprite_ref[0][1] - 16 * w2 * h3 +
 347                                  ((int64_t)1 << (alpha + beta + rho - min_ab + 1));
 348         sprite_delta[0][0] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[0][0]) * h3;
 349         sprite_delta[0][1] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[1][0]) * w3;
 350         sprite_delta[1][0] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[0][1]) * h3;
 351         sprite_delta[1][1] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[1][1]) * w3;
 352
 353         ctx->sprite_shift[0]  = alpha + beta + rho - min_ab;
 354         ctx->sprite_shift[1]  = alpha + beta + rho - min_ab + 2;
 355         break;
 356     }
 357     /* try to simplify the situation */
 358     if (sprite_delta[0][0] == a << ctx->sprite_shift[0] &&
 359         sprite_delta[0][1] == 0 &&
 360         sprite_delta[1][0] == 0 &&
 361         sprite_delta[1][1] == a << ctx->sprite_shift[0]) {
 362         sprite_offset[0][0] >>= ctx->sprite_shift[0];
 363         sprite_offset[0][1] >>= ctx->sprite_shift[0];
 364         sprite_offset[1][0] >>= ctx->sprite_shift[1];
 365         sprite_offset[1][1] >>= ctx->sprite_shift[1];
 366         sprite_delta[0][0] = a;
 367         sprite_delta[0][1] = 0;
 368         sprite_delta[1][0] = 0;
 369         sprite_delta[1][1] = a;
 370         ctx->sprite_shift[0] = 0;
 371         ctx->sprite_shift[1] = 0;
 372         s->real_sprite_warping_points = 1;
 373     } else {
 374         int shift_y = 16 - ctx->sprite_shift[0];
 375         int shift_c = 16 - ctx->sprite_shift[1];
 376
 377         for (i = 0; i < 2; i++) {
 378             if (shift_c < 0 || shift_y < 0 ||
 379                 FFABS(  sprite_offset[0][i]) >= INT_MAX >> shift_y  ||
 380                 FFABS(  sprite_offset[1][i]) >= INT_MAX >> shift_c  ||
 381                 FFABS(   sprite_delta[0][i]) >= INT_MAX >> shift_y  ||
 382                 FFABS(   sprite_delta[1][i]) >= INT_MAX >> shift_y
 383             ) {
 384                 avpriv_request_sample(s->avctx, "Too large sprite shift, delta or offset");
 385                 goto overflow;
 386             }
 387         }
 388
 389         for (i = 0; i < 2; i++) {
 390             sprite_offset[0][i]    *= 1 << shift_y;
 391             sprite_offset[1][i]    *= 1 << shift_c;
 392             sprite_delta[0][i]     *= 1 << shift_y;
 393             sprite_delta[1][i]     *= 1 << shift_y;
 394             ctx->sprite_shift[i]     = 16;
 395
 396         }
 397         for (i = 0; i < 2; i++) {
 398             int64_t sd[2] = {
 399                 sprite_delta[i][0] - a * (1LL<<16),
 400                 sprite_delta[i][1] - a * (1LL<<16)
 401             };
 402
 403             if (llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
 404                 llabs(sprite_offset[0][i] + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
 405                 llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL) + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
 406                 llabs(sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
 407                 llabs(sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
 408                 llabs(sd[0]) >= INT_MAX ||
 409                 llabs(sd[1]) >= INT_MAX ||
 410                 llabs(sprite_offset[0][i] + sd[0] * (w+16LL)) >= INT_MAX ||
 411                 llabs(sprite_offset[0][i] + sd[1] * (h+16LL)) >= INT_MAX ||
 412                 llabs(sprite_offset[0][i] + sd[0] * (w+16LL) + sd[1] * (h+16LL)) >= INT_MAX
 413             ) {
 414                 avpriv_request_sample(s->avctx, "Overflow on sprite points");
 415                 goto overflow;
 416             }
 417         }
 418         s->real_sprite_warping_points = ctx->num_sprite_warping_points;
 419     }
 420
 421     for (i = 0; i < 4; i++) {
 422         s->sprite_offset[i&1][i>>1] = sprite_offset[i&1][i>>1];
 423         s->sprite_delta [i&1][i>>1] = sprite_delta [i&1][i>>1];
 424     }
 425
 426     return 0;
 427 overflow:
 428     memset(s->sprite_offset, 0, sizeof(s->sprite_offset));
 429     memset(s->sprite_delta, 0, sizeof(s->sprite_delta));
 430     return AVERROR_PATCHWELCOME;
 431 }
 432
 433 static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
 434     MpegEncContext *s = &ctx->m;
 435     int len = FFMIN(ctx->time_increment_bits + 3, 15);
 436
 437     get_bits(gb, len);
 438     if (get_bits1(gb))
 439         get_bits(gb, len);
 440     check_marker(s->avctx, gb, "after new_pred");
 441
 442     return 0;
 443 }
 444
 445 /**
 446  * Decode the next video packet.
 447  * @return <0 if something went wrong
 448  */
 449 int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
 450 {
 451     MpegEncContext *s = &ctx->m;
 452
 453     int mb_num_bits      = av_log2(s->mb_num - 1) + 1;
 454     int header_extension = 0, mb_num, len;
 455
 456     /* is there enough space left for a video packet + header */
 457     if (get_bits_count(&s->gb) > s->gb.size_in_bits - 20)
 458         return AVERROR_INVALIDDATA;
 459
 460     for (len = 0; len < 32; len++)
 461         if (get_bits1(&s->gb))
 462             break;
 463
 464     if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
 465         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
 466         return AVERROR_INVALIDDATA;
 467     }
 468
 469     if (ctx->shape != RECT_SHAPE) {
 470         header_extension = get_bits1(&s->gb);
 471         // FIXME more stuff here
 472     }
 473
 474     mb_num = get_bits(&s->gb, mb_num_bits);
 475     if (mb_num >= s->mb_num || !mb_num) {
 476         av_log(s->avctx, AV_LOG_ERROR,
 477                "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
 478         return AVERROR_INVALIDDATA;
 479     }
 480
 481     s->mb_x = mb_num % s->mb_width;
 482     s->mb_y = mb_num / s->mb_width;
 483
 484     if (ctx->shape != BIN_ONLY_SHAPE) {
 485         int qscale = get_bits(&s->gb, s->quant_precision);
 486         if (qscale)
 487             s->chroma_qscale = s->qscale = qscale;
 488     }
 489
 490     if (ctx->shape == RECT_SHAPE)
 491         header_extension = get_bits1(&s->gb);
 492
 493     if (header_extension) {
 494         int time_incr = 0;
 495
 496         while (get_bits1(&s->gb) != 0)
 497             time_incr++;
 498
 499         check_marker(s->avctx, &s->gb, "before time_increment in video packed header");
 500         skip_bits(&s->gb, ctx->time_increment_bits);      /* time_increment */
 501         check_marker(s->avctx, &s->gb, "before vop_coding_type in video packed header");
 502
 503         skip_bits(&s->gb, 2); /* vop coding type */
 504         // FIXME not rect stuff here
 505
 506         if (ctx->shape != BIN_ONLY_SHAPE) {
 507             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
 508             // FIXME don't just ignore everything
 509             if (s->pict_type == AV_PICTURE_TYPE_S &&
 510                 ctx->vol_sprite_usage == GMC_SPRITE) {
 511                 if (mpeg4_decode_sprite_trajectory(ctx, &s->gb) < 0)
 512                     return AVERROR_INVALIDDATA;
 513                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
 514             }
 515
 516             // FIXME reduced res stuff here
 517
 518             if (s->pict_type != AV_PICTURE_TYPE_I) {
 519                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
 520                 if (f_code == 0)
 521                     av_log(s->avctx, AV_LOG_ERROR,
 522                            "Error, video packet header damaged (f_code=0)\n");
 523             }
 524             if (s->pict_type == AV_PICTURE_TYPE_B) {
 525                 int b_code = get_bits(&s->gb, 3);
 526                 if (b_code == 0)
 527                     av_log(s->avctx, AV_LOG_ERROR,
 528                            "Error, video packet header damaged (b_code=0)\n");
 529             }
 530         }
 531     }
 532     if (ctx->new_pred)
 533         decode_new_pred(ctx, &s->gb);
 534
 535     return 0;
 536 }
 537
 538 static void reset_studio_dc_predictors(MpegEncContext *s)
 539 {
 540     /* Reset DC Predictors */
 541     s->last_dc[0] =
 542     s->last_dc[1] =
 543     s->last_dc[2] = 1 << (s->avctx->bits_per_raw_sample + s->dct_precision + s->intra_dc_precision - 1);
 544 }
 545
 546 /**
 547  * Decode the next video packet.
 548  * @return <0 if something went wrong
 549  */
 550 int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
 551 {
 552     MpegEncContext *s = &ctx->m;
 553     GetBitContext *gb = &s->gb;
 554     unsigned vlc_len;
 555     uint16_t mb_num;
 556
 557     if (get_bits_left(gb) >= 32 && get_bits_long(gb, 32) == SLICE_START_CODE) {
 558         vlc_len = av_log2(s->mb_width * s->mb_height) + 1;
 559         mb_num = get_bits(gb, vlc_len);
 560
 561         if (mb_num >= s->mb_num)
 562             return AVERROR_INVALIDDATA;
 563
 564         s->mb_x = mb_num % s->mb_width;
 565         s->mb_y = mb_num / s->mb_width;
 566
 567         if (ctx->shape != BIN_ONLY_SHAPE)
 568             s->qscale = mpeg_get_qscale(s);
 569
 570         if (get_bits1(gb)) {  /* slice_extension_flag */
 571             skip_bits1(gb);   /* intra_slice */
 572             skip_bits1(gb);   /* slice_VOP_id_enable */
 573             skip_bits(gb, 6); /* slice_VOP_id */
 574             while (get_bits1(gb)) /* extra_bit_slice */
 575                 skip_bits(gb, 8); /* extra_information_slice */
 576         }
 577
 578         reset_studio_dc_predictors(s);
 579     }
 580     else {
 581         return AVERROR_INVALIDDATA;
 582     }
 583
 584     return 0;
 585 }
 586
 587 /**
 588  * Get the average motion vector for a GMC MB.
 589  * @param n either 0 for the x component or 1 for y
 590  * @return the average MV for a GMC MB
 591  */
 592 static inline int get_amv(Mpeg4DecContext *ctx, int n)
 593 {
 594     MpegEncContext *s = &ctx->m;
 595     int x, y, mb_v, sum, dx, dy, shift;
 596     int len     = 1 << (s->f_code + 4);
 597     const int a = s->sprite_warping_accuracy;
 598
 599     if (s->workaround_bugs & FF_BUG_AMV)
 600         len >>= s->quarter_sample;
 601
 602     if (s->real_sprite_warping_points == 1) {
 603         if (ctx->divx_version == 500 && ctx->divx_build == 413 && a >= s->quarter_sample)
 604             sum = s->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
 605         else
 606             sum = RSHIFT(s->sprite_offset[0][n] * (1 << s->quarter_sample), a);
 607     } else {
 608         dx    = s->sprite_delta[n][0];
 609         dy    = s->sprite_delta[n][1];
 610         shift = ctx->sprite_shift[0];
 611         if (n)
 612             dy -= 1 << (shift + a + 1);
 613         else
 614             dx -= 1 << (shift + a + 1);
 615         mb_v = s->sprite_offset[0][n] + dx * s->mb_x * 16U + dy * s->mb_y * 16U;
 616
 617         sum = 0;
 618         for (y = 0; y < 16; y++) {
 619             int v;
 620
 621             v = mb_v + dy * y;
 622             // FIXME optimize
 623             for (x = 0; x < 16; x++) {
 624                 sum += v >> shift;
 625                 v   += dx;
 626             }
 627         }
 628         sum = RSHIFT(sum, a + 8 - s->quarter_sample);
 629     }
 630
 631     if (sum < -len)
 632         sum = -len;
 633     else if (sum >= len)
 634         sum = len - 1;
 635
 636     return sum;
 637 }
 638
 639 /**
 640  * Decode the dc value.
 641  * @param n block index (0-3 are luma, 4-5 are chroma)
 642  * @param dir_ptr the prediction direction will be stored here
 643  * @return the quantized dc
 644  */
 645 static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
 646 {
 647     int level, code;
 648
 649     if (n < 4)
 650         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
 651     else
 652         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
 653
 654     if (code < 0 || code > 9 /* && s->nbit < 9 */) {
 655         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 656         return AVERROR_INVALIDDATA;
 657     }
 658
 659     if (code == 0) {
 660         level = 0;
 661     } else {
 662         if (IS_3IV1) {
 663             if (code == 1)
 664                 level = 2 * get_bits1(&s->gb) - 1;
 665             else {
 666                 if (get_bits1(&s->gb))
 667                     level = get_bits(&s->gb, code - 1) + (1 << (code - 1));
 668                 else
 669                     level = -get_bits(&s->gb, code - 1) - (1 << (code - 1));
 670             }
 671         } else {
 672             level = get_xbits(&s->gb, code);
 673         }
 674
 675         if (code > 8) {
 676             if (get_bits1(&s->gb) == 0) { /* marker */
 677                 if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
 678                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
 679                     return AVERROR_INVALIDDATA;
 680                 }
 681             }
 682         }
 683     }
 684
 685     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
 686 }
 687
 688 /**
 689  * Decode first partition.
 690  * @return number of MBs decoded or <0 if an error occurred
 691  */
 692 static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
 693 {
 694     MpegEncContext *s = &ctx->m;
 695     int mb_num = 0;
 696     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 697
 698     /* decode first partition */
 699     s->first_slice_line = 1;
 700     for (; s->mb_y < s->mb_height; s->mb_y++) {
 701         ff_init_block_index(s);
 702         for (; s->mb_x < s->mb_width; s->mb_x++) {
 703             const int xy = s->mb_x + s->mb_y * s->mb_stride;
 704             int cbpc;
 705             int dir = 0;
 706
 707             mb_num++;
 708             ff_update_block_index(s);
 709             if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
 710                 s->first_slice_line = 0;
 711
 712             if (s->pict_type == AV_PICTURE_TYPE_I) {
 713                 int i;
 714
 715                 do {
 716                     if (show_bits(&s->gb, 19) == DC_MARKER)
 717                         return mb_num - 1;
 718
 719                     cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
 720                     if (cbpc < 0) {
 721                         av_log(s->avctx, AV_LOG_ERROR,
 722                                "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
 723                         return AVERROR_INVALIDDATA;
 724                     }
 725                 } while (cbpc == 8);
 726
 727                 s->cbp_table[xy]               = cbpc & 3;
 728                 s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
 729                 s->mb_intra                    = 1;
 730
 731                 if (cbpc & 4)
 732                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 733
 734                 s->current_picture.qscale_table[xy] = s->qscale;
 735
 736                 s->mbintra_table[xy] = 1;
 737                 for (i = 0; i < 6; i++) {
 738                     int dc_pred_dir;
 739                     int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
 740                     if (dc < 0) {
 741                         av_log(s->avctx, AV_LOG_ERROR,
 742                                "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
 743                         return dc;
 744                     }
 745                     dir <<= 1;
 746                     if (dc_pred_dir)
 747                         dir |= 1;
 748                 }
 749                 s->pred_dir_table[xy] = dir;
 750             } else { /* P/S_TYPE */
 751                 int mx, my, pred_x, pred_y, bits;
 752                 int16_t *const mot_val = s->current_picture.motion_val[0][s->block_index[0]];
 753                 const int stride       = s->b8_stride * 2;
 754
 755 try_again:
 756                 bits = show_bits(&s->gb, 17);
 757                 if (bits == MOTION_MARKER)
 758                     return mb_num - 1;
 759
 760                 skip_bits1(&s->gb);
 761                 if (bits & 0x10000) {
 762                     /* skip mb */
 763                     if (s->pict_type == AV_PICTURE_TYPE_S &&
 764                         ctx->vol_sprite_usage == GMC_SPRITE) {
 765                         s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
 766                                                          MB_TYPE_16x16 |
 767                                                          MB_TYPE_GMC   |
 768                                                          MB_TYPE_L0;
 769                         mx = get_amv(ctx, 0);
 770                         my = get_amv(ctx, 1);
 771                     } else {
 772                         s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
 773                                                          MB_TYPE_16x16 |
 774                                                          MB_TYPE_L0;
 775                         mx = my = 0;
 776                     }
 777                     mot_val[0]          =
 778                     mot_val[2]          =
 779                     mot_val[0 + stride] =
 780                     mot_val[2 + stride] = mx;
 781                     mot_val[1]          =
 782                     mot_val[3]          =
 783                     mot_val[1 + stride] =
 784                     mot_val[3 + stride] = my;
 785
 786                     if (s->mbintra_table[xy])
 787                         ff_clean_intra_table_entries(s);
 788                     continue;
 789                 }
 790
 791                 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 792                 if (cbpc < 0) {
 793                     av_log(s->avctx, AV_LOG_ERROR,
 794                            "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
 795                     return AVERROR_INVALIDDATA;
 796                 }
 797                 if (cbpc == 20)
 798                     goto try_again;
 799
 800                 s->cbp_table[xy] = cbpc & (8 + 3);  // 8 is dquant
 801
 802                 s->mb_intra = ((cbpc & 4) != 0);
 803
 804                 if (s->mb_intra) {
 805                     s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
 806                     s->mbintra_table[xy] = 1;
 807                     mot_val[0]          =
 808                     mot_val[2]          =
 809                     mot_val[0 + stride] =
 810                     mot_val[2 + stride] = 0;
 811                     mot_val[1]          =
 812                     mot_val[3]          =
 813                     mot_val[1 + stride] =
 814                     mot_val[3 + stride] = 0;
 815                 } else {
 816                     if (s->mbintra_table[xy])
 817                         ff_clean_intra_table_entries(s);
 818
 819                     if (s->pict_type == AV_PICTURE_TYPE_S &&
 820                         ctx->vol_sprite_usage == GMC_SPRITE &&
 821                         (cbpc & 16) == 0)
 822                         s->mcsel = get_bits1(&s->gb);
 823                     else
 824                         s->mcsel = 0;
 825
 826                     if ((cbpc & 16) == 0) {
 827                         /* 16x16 motion prediction */
 828
 829                         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 830                         if (!s->mcsel) {
 831                             mx = ff_h263_decode_motion(s, pred_x, s->f_code);
 832                             if (mx >= 0xffff)
 833                                 return AVERROR_INVALIDDATA;
 834
 835                             my = ff_h263_decode_motion(s, pred_y, s->f_code);
 836                             if (my >= 0xffff)
 837                                 return AVERROR_INVALIDDATA;
 838                             s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
 839                                                              MB_TYPE_L0;
 840                         } else {
 841                             mx = get_amv(ctx, 0);
 842                             my = get_amv(ctx, 1);
 843                             s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
 844                                                              MB_TYPE_GMC   |
 845                                                              MB_TYPE_L0;
 846                         }
 847
 848                         mot_val[0]          =
 849                         mot_val[2]          =
 850                         mot_val[0 + stride] =
 851                         mot_val[2 + stride] = mx;
 852                         mot_val[1]          =
 853                         mot_val[3]          =
 854                         mot_val[1 + stride] =
 855                         mot_val[3 + stride] = my;
 856                     } else {
 857                         int i;
 858                         s->current_picture.mb_type[xy] = MB_TYPE_8x8 |
 859                                                          MB_TYPE_L0;
 860                         for (i = 0; i < 4; i++) {
 861                             int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 862                             mx = ff_h263_decode_motion(s, pred_x, s->f_code);
 863                             if (mx >= 0xffff)
 864                                 return AVERROR_INVALIDDATA;
 865
 866                             my = ff_h263_decode_motion(s, pred_y, s->f_code);
 867                             if (my >= 0xffff)
 868                                 return AVERROR_INVALIDDATA;
 869                             mot_val[0] = mx;
 870                             mot_val[1] = my;
 871                         }
 872                     }
 873                 }
 874             }
 875         }
 876         s->mb_x = 0;
 877     }
 878
 879     return mb_num;
 880 }
 881
 882 /**
 883  * decode second partition.
 884  * @return <0 if an error occurred
 885  */
 886 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
 887 {
 888     int mb_num = 0;
 889     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 890
 891     s->mb_x = s->resync_mb_x;
 892     s->first_slice_line = 1;
 893     for (s->mb_y = s->resync_mb_y; mb_num < mb_count; s->mb_y++) {
 894         ff_init_block_index(s);
 895         for (; mb_num < mb_count && s->mb_x < s->mb_width; s->mb_x++) {
 896             const int xy = s->mb_x + s->mb_y * s->mb_stride;
 897
 898             mb_num++;
 899             ff_update_block_index(s);
 900             if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
 901                 s->first_slice_line = 0;
 902
 903             if (s->pict_type == AV_PICTURE_TYPE_I) {
 904                 int ac_pred = get_bits1(&s->gb);
 905                 int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 906                 if (cbpy < 0) {
 907                     av_log(s->avctx, AV_LOG_ERROR,
 908                            "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 909                     return AVERROR_INVALIDDATA;
 910                 }
 911
 912                 s->cbp_table[xy]               |= cbpy << 2;
 913                 s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
 914             } else { /* P || S_TYPE */
 915                 if (IS_INTRA(s->current_picture.mb_type[xy])) {
 916                     int i;
 917                     int dir     = 0;
 918                     int ac_pred = get_bits1(&s->gb);
 919                     int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 920
 921                     if (cbpy < 0) {
 922                         av_log(s->avctx, AV_LOG_ERROR,
 923                                "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 924                         return AVERROR_INVALIDDATA;
 925                     }
 926
 927                     if (s->cbp_table[xy] & 8)
 928                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 929                     s->current_picture.qscale_table[xy] = s->qscale;
 930
 931                     for (i = 0; i < 6; i++) {
 932                         int dc_pred_dir;
 933                         int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
 934                         if (dc < 0) {
 935                             av_log(s->avctx, AV_LOG_ERROR,
 936                                    "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
 937                             return dc;
 938                         }
 939                         dir <<= 1;
 940                         if (dc_pred_dir)
 941                             dir |= 1;
 942                     }
 943                     s->cbp_table[xy]               &= 3;  // remove dquant
 944                     s->cbp_table[xy]               |= cbpy << 2;
 945                     s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
 946                     s->pred_dir_table[xy]           = dir;
 947                 } else if (IS_SKIP(s->current_picture.mb_type[xy])) {
 948                     s->current_picture.qscale_table[xy] = s->qscale;
 949                     s->cbp_table[xy]                    = 0;
 950                 } else {
 951                     int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 952
 953                     if (cbpy < 0) {
 954                         av_log(s->avctx, AV_LOG_ERROR,
 955                                "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 956                         return AVERROR_INVALIDDATA;
 957                     }
 958
 959                     if (s->cbp_table[xy] & 8)
 960                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 961                     s->current_picture.qscale_table[xy] = s->qscale;
 962
 963                     s->cbp_table[xy] &= 3;  // remove dquant
 964                     s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
 965                 }
 966             }
 967         }
 968         if (mb_num >= mb_count)
 969             return 0;
 970         s->mb_x = 0;
 971     }
 972     return 0;
 973 }
 974
 975 /**
 976  * Decode the first and second partition.
 977  * @return <0 if error (and sets error type in the error_status_table)
 978  */
 979 int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
 980 {
 981     MpegEncContext *s = &ctx->m;
 982     int mb_num;
 983     int ret;
 984     const int part_a_error = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR;
 985     const int part_a_end   = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_END   | ER_MV_END)   : ER_MV_END;
 986
 987     mb_num = mpeg4_decode_partition_a(ctx);
 988     if (mb_num <= 0) {
 989         ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 990                         s->mb_x, s->mb_y, part_a_error);
 991         return mb_num ? mb_num : AVERROR_INVALIDDATA;
 992     }
 993
 994     if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) {
 995         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
 996         ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 997                         s->mb_x, s->mb_y, part_a_error);
 998         return AVERROR_INVALIDDATA;
 999     }
1000
1001     s->mb_num_left = mb_num;
1002
1003     if (s->pict_type == AV_PICTURE_TYPE_I) {
1004         while (show_bits(&s->gb, 9) == 1)
1005             skip_bits(&s->gb, 9);
1006         if (get_bits(&s->gb, 19) != DC_MARKER) {
1007             av_log(s->avctx, AV_LOG_ERROR,
1008                    "marker missing after first I partition at %d %d\n",
1009                    s->mb_x, s->mb_y);
1010             return AVERROR_INVALIDDATA;
1011         }
1012     } else {
1013         while (show_bits(&s->gb, 10) == 1)
1014             skip_bits(&s->gb, 10);
1015         if (get_bits(&s->gb, 17) != MOTION_MARKER) {
1016             av_log(s->avctx, AV_LOG_ERROR,
1017                    "marker missing after first P partition at %d %d\n",
1018                    s->mb_x, s->mb_y);
1019             return AVERROR_INVALIDDATA;
1020         }
1021     }
1022     ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1023                     s->mb_x - 1, s->mb_y, part_a_end);
1024
1025     ret = mpeg4_decode_partition_b(s, mb_num);
1026     if (ret < 0) {
1027         if (s->pict_type == AV_PICTURE_TYPE_P)
1028             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1029                             s->mb_x, s->mb_y, ER_DC_ERROR);
1030         return ret;
1031     } else {
1032         if (s->pict_type == AV_PICTURE_TYPE_P)
1033             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1034                             s->mb_x - 1, s->mb_y, ER_DC_END);
1035     }
1036
1037     return 0;
1038 }
1039
1040 /**
1041  * Decode a block.
1042  * @return <0 if an error occurred
1043  */
1044 static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
1045                                      int n, int coded, int intra, int rvlc)
1046 {
1047     MpegEncContext *s = &ctx->m;
1048     int level, i, last, run, qmul, qadd;
1049     int av_uninit(dc_pred_dir);
1050     RLTable *rl;
1051     RL_VLC_ELEM *rl_vlc;
1052     const uint8_t *scan_table;
1053
1054     // Note intra & rvlc should be optimized away if this is inlined
1055
1056     if (intra) {
1057         if (ctx->use_intra_dc_vlc) {
1058             /* DC coef */
1059             if (s->partitioned_frame) {
1060                 level = s->dc_val[0][s->block_index[n]];
1061                 if (n < 4)
1062                     level = FASTDIV((level + (s->y_dc_scale >> 1)), s->y_dc_scale);
1063                 else
1064                     level = FASTDIV((level + (s->c_dc_scale >> 1)), s->c_dc_scale);
1065                 dc_pred_dir = (s->pred_dir_table[s->mb_x + s->mb_y * s->mb_stride] << n) & 32;
1066             } else {
1067                 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1068                 if (level < 0)
1069                     return level;
1070             }
1071             block[0] = level;
1072             i        = 0;
1073         } else {
1074             i = -1;
1075             ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
1076         }
1077         if (!coded)
1078             goto not_coded;
1079
1080         if (rvlc) {
1081             rl     = &ff_rvlc_rl_intra;
1082             rl_vlc = ff_rvlc_rl_intra.rl_vlc[0];
1083         } else {
1084             rl     = &ff_mpeg4_rl_intra;
1085             rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
1086         }
1087         if (s->ac_pred) {
1088             if (dc_pred_dir == 0)
1089                 scan_table = s->intra_v_scantable.permutated;  /* left */
1090             else
1091                 scan_table = s->intra_h_scantable.permutated;  /* top */
1092         } else {
1093             scan_table = s->intra_scantable.permutated;
1094         }
1095         qmul = 1;
1096         qadd = 0;
1097     } else {
1098         i = -1;
1099         if (!coded) {
1100             s->block_last_index[n] = i;
1101             return 0;
1102         }
1103         if (rvlc)
1104             rl = &ff_rvlc_rl_inter;
1105         else
1106             rl = &ff_h263_rl_inter;
1107
1108         scan_table = s->intra_scantable.permutated;
1109
1110         if (s->mpeg_quant) {
1111             qmul = 1;
1112             qadd = 0;
1113             if (rvlc)
1114                 rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
1115             else
1116                 rl_vlc = ff_h263_rl_inter.rl_vlc[0];
1117         } else {
1118             qmul = s->qscale << 1;
1119             qadd = (s->qscale - 1) | 1;
1120             if (rvlc)
1121                 rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
1122             else
1123                 rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
1124         }
1125     }
1126     {
1127         OPEN_READER(re, &s->gb);
1128         for (;;) {
1129             UPDATE_CACHE(re, &s->gb);
1130             GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1131             if (level == 0) {
1132                 /* escape */
1133                 if (rvlc) {
1134                     if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1135                         av_log(s->avctx, AV_LOG_ERROR,
1136                                "1. marker bit missing in rvlc esc\n");
1137                         return AVERROR_INVALIDDATA;
1138                     }
1139                     SKIP_CACHE(re, &s->gb, 1);
1140
1141                     last = SHOW_UBITS(re, &s->gb, 1);
1142                     SKIP_CACHE(re, &s->gb, 1);
1143                     run = SHOW_UBITS(re, &s->gb, 6);
1144                     SKIP_COUNTER(re, &s->gb, 1 + 1 + 6);
1145                     UPDATE_CACHE(re, &s->gb);
1146
1147                     if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1148                         av_log(s->avctx, AV_LOG_ERROR,
1149                                "2. marker bit missing in rvlc esc\n");
1150                         return AVERROR_INVALIDDATA;
1151                     }
1152                     SKIP_CACHE(re, &s->gb, 1);
1153
1154                     level = SHOW_UBITS(re, &s->gb, 11);
1155                     SKIP_CACHE(re, &s->gb, 11);
1156
1157                     if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
1158                         av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
1159                         return AVERROR_INVALIDDATA;
1160                     }
1161                     SKIP_CACHE(re, &s->gb, 5);
1162
1163                     level = level * qmul + qadd;
1164                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1165                     SKIP_COUNTER(re, &s->gb, 1 + 11 + 5 + 1);
1166
1167                     i += run + 1;
1168                     if (last)
1169                         i += 192;
1170                 } else {
1171                     int cache;
1172                     cache = GET_CACHE(re, &s->gb);
1173
1174                     if (IS_3IV1)
1175                         cache ^= 0xC0000000;
1176
1177                     if (cache & 0x80000000) {
1178                         if (cache & 0x40000000) {
1179                             /* third escape */
1180                             SKIP_CACHE(re, &s->gb, 2);
1181                             last = SHOW_UBITS(re, &s->gb, 1);
1182                             SKIP_CACHE(re, &s->gb, 1);
1183                             run = SHOW_UBITS(re, &s->gb, 6);
1184                             SKIP_COUNTER(re, &s->gb, 2 + 1 + 6);
1185                             UPDATE_CACHE(re, &s->gb);
1186
1187                             if (IS_3IV1) {
1188                                 level = SHOW_SBITS(re, &s->gb, 12);
1189                                 LAST_SKIP_BITS(re, &s->gb, 12);
1190                             } else {
1191                                 if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1192                                     av_log(s->avctx, AV_LOG_ERROR,
1193                                            "1. marker bit missing in 3. esc\n");
1194                                     if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
1195                                         return AVERROR_INVALIDDATA;
1196                                 }
1197                                 SKIP_CACHE(re, &s->gb, 1);
1198
1199                                 level = SHOW_SBITS(re, &s->gb, 12);
1200                                 SKIP_CACHE(re, &s->gb, 12);
1201
1202                                 if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1203                                     av_log(s->avctx, AV_LOG_ERROR,
1204                                            "2. marker bit missing in 3. esc\n");
1205                                     if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
1206                                         return AVERROR_INVALIDDATA;
1207                                 }
1208
1209                                 SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
1210                             }
1211
1212 #if 0
1213                             if (s->error_recognition >= FF_ER_COMPLIANT) {
1214                                 const int abs_level= FFABS(level);
1215                                 if (abs_level<=MAX_LEVEL && run<=MAX_RUN) {
1216                                     const int run1= run - rl->max_run[last][abs_level] - 1;
1217                                     if (abs_level <= rl->max_level[last][run]) {
1218                                         av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1219                                         return AVERROR_INVALIDDATA;
1220                                     }
1221                                     if (s->error_recognition > FF_ER_COMPLIANT) {
1222                                         if (abs_level <= rl->max_level[last][run]*2) {
1223                                             av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1224                                             return AVERROR_INVALIDDATA;
1225                                         }
1226                                         if (run1 >= 0 && abs_level <= rl->max_level[last][run1]) {
1227                                             av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1228                                             return AVERROR_INVALIDDATA;
1229                                         }
1230                                     }
1231                                 }
1232                             }
1233 #endif
1234                             if (level > 0)
1235                                 level = level * qmul + qadd;
1236                             else
1237                                 level = level * qmul - qadd;
1238
1239                             if ((unsigned)(level + 2048) > 4095) {
1240                                 if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) {
1241                                     if (level > 2560 || level < -2560) {
1242                                         av_log(s->avctx, AV_LOG_ERROR,
1243                                                "|level| overflow in 3. esc, qp=%d\n",
1244                                                s->qscale);
1245                                         return AVERROR_INVALIDDATA;
1246                                     }
1247                                 }
1248                                 level = level < 0 ? -2048 : 2047;
1249                             }
1250
1251                             i += run + 1;
1252                             if (last)
1253                                 i += 192;
1254                         } else {
1255                             /* second escape */
1256                             SKIP_BITS(re, &s->gb, 2);
1257                             GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1258                             i    += run + rl->max_run[run >> 7][level / qmul] + 1;  // FIXME opt indexing
1259                             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1260                             LAST_SKIP_BITS(re, &s->gb, 1);
1261                         }
1262                     } else {
1263                         /* first escape */
1264                         SKIP_BITS(re, &s->gb, 1);
1265                         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1266                         i    += run;
1267                         level = level + rl->max_level[run >> 7][(run - 1) & 63] * qmul;  // FIXME opt indexing
1268                         level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1269                         LAST_SKIP_BITS(re, &s->gb, 1);
1270                     }
1271                 }
1272             } else {
1273                 i    += run;
1274                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1275                 LAST_SKIP_BITS(re, &s->gb, 1);
1276             }
1277             ff_tlog(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
1278             if (i > 62) {
1279                 i -= 192;
1280                 if (i & (~63)) {
1281                     av_log(s->avctx, AV_LOG_ERROR,
1282                            "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1283                     return AVERROR_INVALIDDATA;
1284                 }
1285
1286                 block[scan_table[i]] = level;
1287                 break;
1288             }
1289
1290             block[scan_table[i]] = level;
1291         }
1292         CLOSE_READER(re, &s->gb);
1293     }
1294
1295 not_coded:
1296     if (intra) {
1297         if (!ctx->use_intra_dc_vlc) {
1298             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
1299
1300             i -= i >> 31;  // if (i == -1) i = 0;
1301         }
1302
1303         ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1304         if (s->ac_pred)
1305             i = 63;  // FIXME not optimal
1306     }
1307     s->block_last_index[n] = i;
1308     return 0;
1309 }
1310
1311 /**
1312  * decode partition C of one MB.
1313  * @return <0 if an error occurred
1314  */
1315 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
1316 {
1317     Mpeg4DecContext *ctx = s->avctx->priv_data;
1318     int cbp, mb_type;
1319     const int xy = s->mb_x + s->mb_y * s->mb_stride;
1320
1321     av_assert2(s == (void*)ctx);
1322
1323     mb_type = s->current_picture.mb_type[xy];
1324     cbp     = s->cbp_table[xy];
1325
1326     ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1327
1328     if (s->current_picture.qscale_table[xy] != s->qscale)
1329         ff_set_qscale(s, s->current_picture.qscale_table[xy]);
1330
1331     if (s->pict_type == AV_PICTURE_TYPE_P ||
1332         s->pict_type == AV_PICTURE_TYPE_S) {
1333         int i;
1334         for (i = 0; i < 4; i++) {
1335             s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
1336             s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
1337         }
1338         s->mb_intra = IS_INTRA(mb_type);
1339
1340         if (IS_SKIP(mb_type)) {
1341             /* skip mb */
1342             for (i = 0; i < 6; i++)
1343                 s->block_last_index[i] = -1;
1344             s->mv_dir  = MV_DIR_FORWARD;
1345             s->mv_type = MV_TYPE_16X16;
1346             if (s->pict_type == AV_PICTURE_TYPE_S
1347                 && ctx->vol_sprite_usage == GMC_SPRITE) {
1348                 s->mcsel      = 1;
1349                 s->mb_skipped = 0;
1350             } else {
1351                 s->mcsel      = 0;
1352                 s->mb_skipped = 1;
1353             }
1354         } else if (s->mb_intra) {
1355             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
1356         } else if (!s->mb_intra) {
1357             // s->mcsel = 0;  // FIXME do we need to init that?
1358
1359             s->mv_dir = MV_DIR_FORWARD;
1360             if (IS_8X8(mb_type)) {
1361                 s->mv_type = MV_TYPE_8X8;
1362             } else {
1363                 s->mv_type = MV_TYPE_16X16;
1364             }
1365         }
1366     } else { /* I-Frame */
1367         s->mb_intra = 1;
1368         s->ac_pred  = IS_ACPRED(s->current_picture.mb_type[xy]);
1369     }
1370
1371     if (!IS_SKIP(mb_type)) {
1372         int i;
1373         s->bdsp.clear_blocks(s->block[0]);
1374         /* decode each block */
1375         for (i = 0; i < 6; i++) {
1376             if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, s->mb_intra, ctx->rvlc) < 0) {
1377                 av_log(s->avctx, AV_LOG_ERROR,
1378                        "texture corrupted at %d %d %d\n",
1379                        s->mb_x, s->mb_y, s->mb_intra);
1380                 return AVERROR_INVALIDDATA;
1381             }
1382             cbp += cbp;
1383         }
1384     }
1385
1386     /* per-MB end of slice check */
1387     if (--s->mb_num_left <= 0) {
1388         if (mpeg4_is_resync(ctx))
1389             return SLICE_END;
1390         else
1391             return SLICE_NOEND;
1392     } else {
1393         if (mpeg4_is_resync(ctx)) {
1394             const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
1395             if (s->cbp_table[xy + delta])
1396                 return SLICE_END;
1397         }
1398         return SLICE_OK;
1399     }
1400 }
1401
1402 static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
1403 {
1404     Mpeg4DecContext *ctx = s->avctx->priv_data;
1405     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1406     int16_t *mot_val;
1407     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1408     const int xy = s->mb_x + s->mb_y * s->mb_stride;
1409
1410     av_assert2(s ==  (void*)ctx);
1411     av_assert2(s->h263_pred);
1412
1413     if (s->pict_type == AV_PICTURE_TYPE_P ||
1414         s->pict_type == AV_PICTURE_TYPE_S) {
1415         do {
1416             if (get_bits1(&s->gb)) {
1417                 /* skip mb */
1418                 s->mb_intra = 0;
1419                 for (i = 0; i < 6; i++)
1420                     s->block_last_index[i] = -1;
1421                 s->mv_dir  = MV_DIR_FORWARD;
1422                 s->mv_type = MV_TYPE_16X16;
1423                 if (s->pict_type == AV_PICTURE_TYPE_S &&
1424                     ctx->vol_sprite_usage == GMC_SPRITE) {
1425                     s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
1426                                                      MB_TYPE_GMC   |
1427                                                      MB_TYPE_16x16 |
1428                                                      MB_TYPE_L0;
1429                     s->mcsel       = 1;
1430                     s->mv[0][0][0] = get_amv(ctx, 0);
1431                     s->mv[0][0][1] = get_amv(ctx, 1);
1432                     s->mb_skipped  = 0;
1433                 } else {
1434                     s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
1435                                                      MB_TYPE_16x16 |
1436                                                      MB_TYPE_L0;
1437                     s->mcsel       = 0;
1438                     s->mv[0][0][0] = 0;
1439                     s->mv[0][0][1] = 0;
1440                     s->mb_skipped  = 1;
1441                 }
1442                 goto end;
1443             }
1444             cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1445             if (cbpc < 0) {
1446                 av_log(s->avctx, AV_LOG_ERROR,
1447                        "mcbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1448                 return AVERROR_INVALIDDATA;
1449             }
1450         } while (cbpc == 20);
1451
1452         s->bdsp.clear_blocks(s->block[0]);
1453         dquant      = cbpc & 8;
1454         s->mb_intra = ((cbpc & 4) != 0);
1455         if (s->mb_intra)
1456             goto intra;
1457
1458         if (s->pict_type == AV_PICTURE_TYPE_S &&
1459             ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
1460             s->mcsel = get_bits1(&s->gb);
1461         else
1462             s->mcsel = 0;
1463         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
1464         if (cbpy < 0) {
1465             av_log(s->avctx, AV_LOG_ERROR,
1466                    "P cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1467             return AVERROR_INVALIDDATA;
1468         }
1469
1470         cbp = (cbpc & 3) | (cbpy << 2);
1471         if (dquant)
1472             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1473         if ((!s->progressive_sequence) &&
1474             (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE)))
1475             s->interlaced_dct = get_bits1(&s->gb);
1476
1477         s->mv_dir = MV_DIR_FORWARD;
1478         if ((cbpc & 16) == 0) {
1479             if (s->mcsel) {
1480                 s->current_picture.mb_type[xy] = MB_TYPE_GMC   |
1481                                                  MB_TYPE_16x16 |
1482                                                  MB_TYPE_L0;
1483                 /* 16x16 global motion prediction */
1484                 s->mv_type     = MV_TYPE_16X16;
1485                 mx             = get_amv(ctx, 0);
1486                 my             = get_amv(ctx, 1);
1487                 s->mv[0][0][0] = mx;
1488                 s->mv[0][0][1] = my;
1489             } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
1490                 s->current_picture.mb_type[xy] = MB_TYPE_16x8 |
1491                                                  MB_TYPE_L0   |
1492                                                  MB_TYPE_INTERLACED;
1493                 /* 16x8 field motion prediction */
1494                 s->mv_type = MV_TYPE_FIELD;
1495
1496                 s->field_select[0][0] = get_bits1(&s->gb);
1497                 s->field_select[0][1] = get_bits1(&s->gb);
1498
1499                 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1500
1501                 for (i = 0; i < 2; i++) {
1502                     mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1503                     if (mx >= 0xffff)
1504                         return AVERROR_INVALIDDATA;
1505
1506                     my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
1507                     if (my >= 0xffff)
1508                         return AVERROR_INVALIDDATA;
1509
1510                     s->mv[0][i][0] = mx;
1511                     s->mv[0][i][1] = my;
1512                 }
1513             } else {
1514                 s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
1515                 /* 16x16 motion prediction */
1516                 s->mv_type = MV_TYPE_16X16;
1517                 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1518                 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1519
1520                 if (mx >= 0xffff)
1521                     return AVERROR_INVALIDDATA;
1522
1523                 my = ff_h263_decode_motion(s, pred_y, s->f_code);
1524
1525                 if (my >= 0xffff)
1526                     return AVERROR_INVALIDDATA;
1527                 s->mv[0][0][0] = mx;
1528                 s->mv[0][0][1] = my;
1529             }
1530         } else {
1531             s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
1532             s->mv_type                     = MV_TYPE_8X8;
1533             for (i = 0; i < 4; i++) {
1534                 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1535                 mx      = ff_h263_decode_motion(s, pred_x, s->f_code);
1536                 if (mx >= 0xffff)
1537                     return AVERROR_INVALIDDATA;
1538
1539                 my = ff_h263_decode_motion(s, pred_y, s->f_code);
1540                 if (my >= 0xffff)
1541                     return AVERROR_INVALIDDATA;
1542                 s->mv[0][i][0] = mx;
1543                 s->mv[0][i][1] = my;
1544                 mot_val[0]     = mx;
1545                 mot_val[1]     = my;
1546             }
1547         }
1548     } else if (s->pict_type == AV_PICTURE_TYPE_B) {
1549         int modb1;   // first bit of modb
1550         int modb2;   // second bit of modb
1551         int mb_type;
1552
1553         s->mb_intra = 0;  // B-frames never contain intra blocks
1554         s->mcsel    = 0;  //      ...               true gmc blocks
1555
1556         if (s->mb_x == 0) {
1557             for (i = 0; i < 2; i++) {
1558                 s->last_mv[i][0][0] =
1559                 s->last_mv[i][0][1] =
1560                 s->last_mv[i][1][0] =
1561                 s->last_mv[i][1][1] = 0;
1562             }
1563
1564             ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);
1565         }
1566
1567         /* if we skipped it in the future P-frame than skip it now too */
1568         s->mb_skipped = s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x];  // Note, skiptab=0 if last was GMC
1569
1570         if (s->mb_skipped) {
1571             /* skip mb */
1572             for (i = 0; i < 6; i++)
1573                 s->block_last_index[i] = -1;
1574
1575             s->mv_dir      = MV_DIR_FORWARD;
1576             s->mv_type     = MV_TYPE_16X16;
1577             s->mv[0][0][0] =
1578             s->mv[0][0][1] =
1579             s->mv[1][0][0] =
1580             s->mv[1][0][1] = 0;
1581             s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
1582                                              MB_TYPE_16x16 |
1583                                              MB_TYPE_L0;
1584             goto end;
1585         }
1586
1587         modb1 = get_bits1(&s->gb);
1588         if (modb1) {
1589             // like MB_TYPE_B_DIRECT but no vectors coded
1590             mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1;
1591             cbp     = 0;
1592         } else {
1593             modb2   = get_bits1(&s->gb);
1594             mb_type = get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
1595             if (mb_type < 0) {
1596                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
1597                 return AVERROR_INVALIDDATA;
1598             }
1599             mb_type = mb_type_b_map[mb_type];
1600             if (modb2) {
1601                 cbp = 0;
1602             } else {
1603                 s->bdsp.clear_blocks(s->block[0]);
1604                 cbp = get_bits(&s->gb, 6);
1605             }
1606
1607             if ((!IS_DIRECT(mb_type)) && cbp) {
1608                 if (get_bits1(&s->gb))
1609                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2);
1610             }
1611
1612             if (!s->progressive_sequence) {
1613                 if (cbp)
1614                     s->interlaced_dct = get_bits1(&s->gb);
1615
1616                 if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) {
1617                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1618                     mb_type &= ~MB_TYPE_16x16;
1619
1620                     if (USES_LIST(mb_type, 0)) {
1621                         s->field_select[0][0] = get_bits1(&s->gb);
1622                         s->field_select[0][1] = get_bits1(&s->gb);
1623                     }
1624                     if (USES_LIST(mb_type, 1)) {
1625                         s->field_select[1][0] = get_bits1(&s->gb);
1626                         s->field_select[1][1] = get_bits1(&s->gb);
1627                     }
1628                 }
1629             }
1630
1631             s->mv_dir = 0;
1632             if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) {
1633                 s->mv_type = MV_TYPE_16X16;
1634
1635                 if (USES_LIST(mb_type, 0)) {
1636                     s->mv_dir = MV_DIR_FORWARD;
1637
1638                     mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1639                     my = ff_h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1640                     s->last_mv[0][1][0] =
1641                     s->last_mv[0][0][0] =
1642                     s->mv[0][0][0]      = mx;
1643                     s->last_mv[0][1][1] =
1644                     s->last_mv[0][0][1] =
1645                     s->mv[0][0][1]      = my;
1646                 }
1647
1648                 if (USES_LIST(mb_type, 1)) {
1649                     s->mv_dir |= MV_DIR_BACKWARD;
1650
1651                     mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1652                     my = ff_h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1653                     s->last_mv[1][1][0] =
1654                     s->last_mv[1][0][0] =
1655                     s->mv[1][0][0]      = mx;
1656                     s->last_mv[1][1][1] =
1657                     s->last_mv[1][0][1] =
1658                     s->mv[1][0][1]      = my;
1659                 }
1660             } else if (!IS_DIRECT(mb_type)) {
1661                 s->mv_type = MV_TYPE_FIELD;
1662
1663                 if (USES_LIST(mb_type, 0)) {
1664                     s->mv_dir = MV_DIR_FORWARD;
1665
1666                     for (i = 0; i < 2; i++) {
1667                         mx = ff_h263_decode_motion(s, s->last_mv[0][i][0], s->f_code);
1668                         my = ff_h263_decode_motion(s, s->last_mv[0][i][1] / 2, s->f_code);
1669                         s->last_mv[0][i][0] =
1670                         s->mv[0][i][0]      = mx;
1671                         s->last_mv[0][i][1] = (s->mv[0][i][1] = my) * 2;
1672                     }
1673                 }
1674
1675                 if (USES_LIST(mb_type, 1)) {
1676                     s->mv_dir |= MV_DIR_BACKWARD;
1677
1678                     for (i = 0; i < 2; i++) {
1679                         mx = ff_h263_decode_motion(s, s->last_mv[1][i][0], s->b_code);
1680                         my = ff_h263_decode_motion(s, s->last_mv[1][i][1] / 2, s->b_code);
1681                         s->last_mv[1][i][0] =
1682                         s->mv[1][i][0]      = mx;
1683                         s->last_mv[1][i][1] = (s->mv[1][i][1] = my) * 2;
1684                     }
1685                 }
1686             }
1687         }
1688
1689         if (IS_DIRECT(mb_type)) {
1690             if (IS_SKIP(mb_type)) {
1691                 mx =
1692                 my = 0;
1693             } else {
1694                 mx = ff_h263_decode_motion(s, 0, 1);
1695                 my = ff_h263_decode_motion(s, 0, 1);
1696             }
1697
1698             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1699             mb_type  |= ff_mpeg4_set_direct_mv(s, mx, my);
1700         }
1701         s->current_picture.mb_type[xy] = mb_type;
1702     } else { /* I-Frame */
1703         do {
1704             cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1705             if (cbpc < 0) {
1706                 av_log(s->avctx, AV_LOG_ERROR,
1707                        "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1708                 return AVERROR_INVALIDDATA;
1709             }
1710         } while (cbpc == 8);
1711
1712         dquant = cbpc & 4;
1713         s->mb_intra = 1;
1714
1715 intra:
1716         s->ac_pred = get_bits1(&s->gb);
1717         if (s->ac_pred)
1718             s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1719         else
1720             s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1721
1722         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1723         if (cbpy < 0) {
1724             av_log(s->avctx, AV_LOG_ERROR,
1725                    "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1726             return AVERROR_INVALIDDATA;
1727         }
1728         cbp = (cbpc & 3) | (cbpy << 2);
1729
1730         ctx->use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1731
1732         if (dquant)
1733             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1734
1735         if (!s->progressive_sequence)
1736             s->interlaced_dct = get_bits1(&s->gb);
1737
1738         s->bdsp.clear_blocks(s->block[0]);
1739         /* decode each block */
1740         for (i = 0; i < 6; i++) {
1741             if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 1, 0) < 0)
1742                 return AVERROR_INVALIDDATA;
1743             cbp += cbp;
1744         }
1745         goto end;
1746     }
1747
1748     /* decode each block */
1749     for (i = 0; i < 6; i++) {
1750         if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 0, 0) < 0)
1751             return AVERROR_INVALIDDATA;
1752         cbp += cbp;
1753     }
1754
1755 end:
1756     /* per-MB end of slice check */
1757     if (s->codec_id == AV_CODEC_ID_MPEG4) {
1758         int next = mpeg4_is_resync(ctx);
1759         if (next) {
1760             if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
1761                 return AVERROR_INVALIDDATA;
1762             } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
1763                 return SLICE_END;
1764
1765             if (s->pict_type == AV_PICTURE_TYPE_B) {
1766                 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1767                 ff_thread_await_progress(&s->next_picture_ptr->tf,
1768                                          (s->mb_x + delta >= s->mb_width)
1769                                          ? FFMIN(s->mb_y + 1, s->mb_height - 1)
1770                                          : s->mb_y, 0);
1771                 if (s->next_picture.mbskip_table[xy + delta])
1772                     return SLICE_OK;
1773             }
1774
1775             return SLICE_END;
1776         }
1777     }
1778
1779     return SLICE_OK;
1780 }
1781
1782 /* As per spec, studio start code search isn't the same as the old type of start code */
1783 static void next_start_code_studio(GetBitContext *gb)
1784 {
1785     align_get_bits(gb);
1786
1787     while (get_bits_left(gb) >= 24 && show_bits(gb, 24) != 0x1) {
1788         get_bits(gb, 8);
1789     }
1790 }
1791
1792 /* additional_code, vlc index */
1793 static const uint8_t ac_state_tab[22][2] =
1794 {
1795     {0, 0},
1796     {0, 1},
1797     {1, 1},
1798     {2, 1},
1799     {3, 1},
1800     {4, 1},
1801     {5, 1},
1802     {1, 2},
1803     {2, 2},
1804     {3, 2},
1805     {4, 2},
1806     {5, 2},
1807     {6, 2},
1808     {1, 3},
1809     {2, 4},
1810     {3, 5},
1811     {4, 6},
1812     {5, 7},
1813     {6, 8},
1814     {7, 9},
1815     {8, 10},
1816     {0, 11}
1817 };
1818
1819 static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n)
1820 {
1821     Mpeg4DecContext *ctx = s->avctx->priv_data;
1822
1823     int cc, dct_dc_size, dct_diff, code, j, idx = 1, group = 0, run = 0,
1824         additional_code_len, sign, mismatch;
1825     const VLC *cur_vlc = &studio_intra_tab[0];
1826     uint8_t *const scantable = s->intra_scantable.permutated;
1827     const uint16_t *quant_matrix;
1828     uint32_t flc;
1829     const int min = -1 *  (1 << (s->avctx->bits_per_raw_sample + 6));
1830     const int max =      ((1 << (s->avctx->bits_per_raw_sample + 6)) - 1);
1831     int shift =  3 - s->dct_precision;
1832
1833     mismatch = 1;
1834
1835     memset(block, 0, 64 * sizeof(int32_t));
1836
1837     if (n < 4) {
1838         cc = 0;
1839         dct_dc_size = get_vlc2(&s->gb, studio_luma_dc.table, STUDIO_INTRA_BITS, 2);
1840         quant_matrix = s->intra_matrix;
1841     } else {
1842         cc = (n & 1) + 1;
1843         if (ctx->rgb)
1844             dct_dc_size = get_vlc2(&s->gb, studio_luma_dc.table, STUDIO_INTRA_BITS, 2);
1845         else
1846             dct_dc_size = get_vlc2(&s->gb, studio_chroma_dc.table, STUDIO_INTRA_BITS, 2);
1847         quant_matrix = s->chroma_intra_matrix;
1848     }
1849
1850     if (dct_dc_size == 0) {
1851         dct_diff = 0;
1852     } else {
1853         dct_diff = get_xbits(&s->gb, dct_dc_size);
1854
1855         if (dct_dc_size > 8) {
1856             if(!check_marker(s->avctx, &s->gb, "dct_dc_size > 8"))
1857                 return AVERROR_INVALIDDATA;
1858         }
1859
1860     }
1861
1862     s->last_dc[cc] += dct_diff;
1863
1864     if (s->mpeg_quant)
1865         block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision);
1866     else
1867         block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision) * (8 >> s->dct_precision);
1868     /* TODO: support mpeg_quant for AC coefficients */
1869
1870     block[0] = av_clip(block[0], min, max);
1871     mismatch ^= block[0];
1872
1873     /* AC Coefficients */
1874     while (1) {
1875         group = get_vlc2(&s->gb, cur_vlc->table, STUDIO_INTRA_BITS, 2);
1876
1877         if (group < 0) {
1878             av_log(s->avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n");
1879             return AVERROR_INVALIDDATA;
1880         }
1881
1882         additional_code_len = ac_state_tab[group][0];
1883         cur_vlc = &studio_intra_tab[ac_state_tab[group][1]];
1884
1885         if (group == 0) {
1886             /* End of Block */
1887             break;
1888         } else if (group >= 1 && group <= 6) {
1889             /* Zero run length (Table B.47) */
1890             run = 1 << additional_code_len;
1891             if (additional_code_len)
1892                 run += get_bits(&s->gb, additional_code_len);
1893             idx += run;
1894             continue;
1895         } else if (group >= 7 && group <= 12) {
1896             /* Zero run length and +/-1 level (Table B.48) */
1897             code = get_bits(&s->gb, additional_code_len);
1898             sign = code & 1;
1899             code >>= 1;
1900             run = (1 << (additional_code_len - 1)) + code;
1901             idx += run;
1902             if (idx > 63)
1903                 return AVERROR_INVALIDDATA;
1904             j = scantable[idx++];
1905             block[j] = sign ? 1 : -1;
1906         } else if (group >= 13 && group <= 20) {
1907             /* Level value (Table B.49) */
1908             if (idx > 63)
1909                 return AVERROR_INVALIDDATA;
1910             j = scantable[idx++];
1911             block[j] = get_xbits(&s->gb, additional_code_len);
1912         } else if (group == 21) {
1913             /* Escape */
1914             if (idx > 63)
1915                 return AVERROR_INVALIDDATA;
1916             j = scantable[idx++];
1917             additional_code_len = s->avctx->bits_per_raw_sample + s->dct_precision + 4;
1918             flc = get_bits(&s->gb, additional_code_len);
1919             if (flc >> (additional_code_len-1))
1920                 block[j] = -1 * (( flc ^ ((1 << additional_code_len) -1)) + 1);
1921             else
1922                 block[j] = flc;
1923         }
1924         block[j] = ((block[j] * quant_matrix[j] * s->qscale) * (1 << shift)) / 16;
1925         block[j] = av_clip(block[j], min, max);
1926         mismatch ^= block[j];
1927     }
1928
1929     block[63] ^= mismatch & 1;
1930
1931     return 0;
1932 }
1933
1934 static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[256], int n)
1935 {
1936     int i, j, w, h, idx = 0;
1937     int block_mean, rice_parameter, rice_prefix_code, rice_suffix_code,
1938         dpcm_residual, left, top, topleft, min_left_top, max_left_top, p, p2, output;
1939     h = 16 >> (n ? s->chroma_y_shift : 0);
1940     w = 16 >> (n ? s->chroma_x_shift : 0);
1941
1942     block_mean = get_bits(&s->gb, s->avctx->bits_per_raw_sample);
1943     if (block_mean == 0){
1944         av_log(s->avctx, AV_LOG_ERROR, "Forbidden block_mean\n");
1945         return AVERROR_INVALIDDATA;
1946     }
1947     s->last_dc[n] = block_mean * (1 << (s->dct_precision + s->intra_dc_precision));
1948
1949     rice_parameter = get_bits(&s->gb, 4);
1950     if (rice_parameter == 0) {
1951         av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n");
1952         return AVERROR_INVALIDDATA;
1953     }
1954
1955     if (rice_parameter == 15)
1956         rice_parameter = 0;
1957
1958     if (rice_parameter > 11) {
1959         av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n");
1960         return AVERROR_INVALIDDATA;
1961     }
1962
1963     for (i = 0; i < h; i++) {
1964         output = 1 << (s->avctx->bits_per_raw_sample - 1);
1965         top = 1 << (s->avctx->bits_per_raw_sample - 1);
1966
1967         for (j = 0; j < w; j++) {
1968             left = output;
1969             topleft = top;
1970
1971             rice_prefix_code = get_unary(&s->gb, 1, 12);
1972
1973             /* Escape */
1974             if (rice_prefix_code == 11)
1975                 dpcm_residual = get_bits(&s->gb, s->avctx->bits_per_raw_sample);
1976             else {
1977                 if (rice_prefix_code == 12) {
1978                     av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n");
1979                     return AVERROR_INVALIDDATA;
1980                 }
1981                 rice_suffix_code = get_bitsz(&s->gb, rice_parameter);
1982                 dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code;
1983             }
1984
1985             /* Map to a signed residual */
1986             if (dpcm_residual & 1)
1987                 dpcm_residual = (-1 * dpcm_residual) >> 1;
1988             else
1989                 dpcm_residual = (dpcm_residual >> 1);
1990
1991             if (i != 0)
1992                 top = macroblock[idx-w];
1993
1994             p = left + top - topleft;
1995             min_left_top = FFMIN(left, top);
1996             if (p < min_left_top)
1997                 p = min_left_top;
1998
1999             max_left_top = FFMAX(left, top);
2000             if (p > max_left_top)
2001                 p = max_left_top;
2002
2003             p2 = (FFMIN(min_left_top, topleft) + FFMAX(max_left_top, topleft)) >> 1;
2004             if (p2 == p)
2005                 p2 = block_mean;
2006
2007             if (p2 > p)
2008                 dpcm_residual *= -1;
2009
2010             macroblock[idx++] = output = (dpcm_residual + p) & ((1 << s->avctx->bits_per_raw_sample) - 1);
2011         }
2012     }
2013
2014     return 0;
2015 }
2016
2017 static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
2018 {
2019     int i;
2020
2021     s->dpcm_direction = 0;
2022
2023     /* StudioMacroblock */
2024     /* Assumes I-VOP */
2025     s->mb_intra = 1;
2026     if (get_bits1(&s->gb)) { /* compression_mode */
2027         /* DCT */
2028         /* macroblock_type, 1 or 2-bit VLC */
2029         if (!get_bits1(&s->gb)) {
2030             skip_bits1(&s->gb);
2031             s->qscale = mpeg_get_qscale(s);
2032         }
2033
2034         for (i = 0; i < mpeg4_block_count[s->chroma_format]; i++) {
2035             if (mpeg4_decode_studio_block(s, (*s->block32)[i], i) < 0)
2036                 return AVERROR_INVALIDDATA;
2037         }
2038     } else {
2039         /* DPCM */
2040         check_marker(s->avctx, &s->gb, "DPCM block start");
2041         s->dpcm_direction = get_bits1(&s->gb) ? -1 : 1;
2042         for (i = 0; i < 3; i++) {
2043             if (mpeg4_decode_dpcm_macroblock(s, (*s->dpcm_macroblock)[i], i) < 0)
2044                 return AVERROR_INVALIDDATA;
2045         }
2046     }
2047
2048     if (get_bits_left(&s->gb) >= 24 && show_bits(&s->gb, 23) == 0) {
2049         next_start_code_studio(&s->gb);
2050         return SLICE_END;
2051     }
2052
2053     //vcon-stp9L1.bits (first frame)
2054     if (get_bits_left(&s->gb) == 0)
2055         return SLICE_END;
2056
2057     //vcon-stp2L1.bits, vcon-stp3L1.bits, vcon-stp6L1.bits, vcon-stp7L1.bits, vcon-stp8L1.bits, vcon-stp10L1.bits (first frame)
2058     if (get_bits_left(&s->gb) < 8U && show_bits(&s->gb, get_bits_left(&s->gb)) == 0)
2059         return SLICE_END;
2060
2061     return SLICE_OK;
2062 }
2063
2064 static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
2065 {
2066     int hours, minutes, seconds;
2067
2068     if (!show_bits(gb, 23)) {
2069         av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
2070         return AVERROR_INVALIDDATA;
2071     }
2072
2073     hours   = get_bits(gb, 5);
2074     minutes = get_bits(gb, 6);
2075     check_marker(s->avctx, gb, "in gop_header");
2076     seconds = get_bits(gb, 6);
2077
2078     s->time_base = seconds + 60*(minutes + 60*hours);
2079
2080     skip_bits1(gb);
2081     skip_bits1(gb);
2082
2083     return 0;
2084 }
2085
2086 static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int *profile, int *level)
2087 {
2088
2089     *profile = get_bits(gb, 4);
2090     *level   = get_bits(gb, 4);
2091
2092     // for Simple profile, level 0
2093     if (*profile == 0 && *level == 8) {
2094         *level = 0;
2095     }
2096
2097     return 0;
2098 }
2099
2100 static int mpeg4_decode_visual_object(MpegEncContext *s, GetBitContext *gb)
2101 {
2102     int visual_object_type;
2103     int is_visual_object_identifier = get_bits1(gb);
2104
2105     if (is_visual_object_identifier) {
2106         skip_bits(gb, 4+3);
2107     }
2108     visual_object_type = get_bits(gb, 4);
2109
2110     if (visual_object_type == VOT_VIDEO_ID ||
2111         visual_object_type == VOT_STILL_TEXTURE_ID) {
2112         int video_signal_type = get_bits1(gb);
2113         if (video_signal_type) {
2114             int video_range, color_description;
2115             skip_bits(gb, 3); // video_format
2116             video_range = get_bits1(gb);
2117             color_description = get_bits1(gb);
2118
2119             s->avctx->color_range = video_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
2120
2121             if (color_description) {
2122                 s->avctx->color_primaries = get_bits(gb, 8);
2123                 s->avctx->color_trc       = get_bits(gb, 8);
2124                 s->avctx->colorspace      = get_bits(gb, 8);
2125             }
2126         }
2127     }
2128
2129     return 0;
2130 }
2131
2132 static void mpeg4_load_default_matrices(MpegEncContext *s)
2133 {
2134     int i, v;
2135
2136     /* load default matrices */
2137     for (i = 0; i < 64; i++) {
2138         int j = s->idsp.idct_permutation[i];
2139         v = ff_mpeg4_default_intra_matrix[i];
2140         s->intra_matrix[j]        = v;
2141         s->chroma_intra_matrix[j] = v;
2142
2143         v = ff_mpeg4_default_non_intra_matrix[i];
2144         s->inter_matrix[j]        = v;
2145         s->chroma_inter_matrix[j] = v;
2146     }
2147 }
2148
2149 static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
2150 {
2151     int i, j, v;
2152
2153     if (get_bits1(gb)) {
2154         if (get_bits_left(gb) < 64*8)
2155             return AVERROR_INVALIDDATA;
2156         /* intra_quantiser_matrix */
2157         for (i = 0; i < 64; i++) {
2158             v = get_bits(gb, 8);
2159             j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2160             s->intra_matrix[j]        = v;
2161             s->chroma_intra_matrix[j] = v;
2162         }
2163     }
2164
2165     if (get_bits1(gb)) {
2166         if (get_bits_left(gb) < 64*8)
2167             return AVERROR_INVALIDDATA;
2168         /* non_intra_quantiser_matrix */
2169         for (i = 0; i < 64; i++) {
2170             get_bits(gb, 8);
2171         }
2172     }
2173
2174     if (get_bits1(gb)) {
2175         if (get_bits_left(gb) < 64*8)
2176             return AVERROR_INVALIDDATA;
2177         /* chroma_intra_quantiser_matrix */
2178         for (i = 0; i < 64; i++) {
2179             v = get_bits(gb, 8);
2180             j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2181             s->chroma_intra_matrix[j] = v;
2182         }
2183     }
2184
2185     if (get_bits1(gb)) {
2186         if (get_bits_left(gb) < 64*8)
2187             return AVERROR_INVALIDDATA;
2188         /* chroma_non_intra_quantiser_matrix */
2189         for (i = 0; i < 64; i++) {
2190             get_bits(gb, 8);
2191         }
2192     }
2193
2194     next_start_code_studio(gb);
2195     return 0;
2196 }
2197
2198 static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id)
2199 {
2200     uint32_t startcode;
2201     uint8_t extension_type;
2202
2203     startcode = show_bits_long(gb, 32);
2204     if (startcode == USER_DATA_STARTCODE || startcode == EXT_STARTCODE) {
2205
2206         if ((id == 2 || id == 4) && startcode == EXT_STARTCODE) {
2207             skip_bits_long(gb, 32);
2208             extension_type = get_bits(gb, 4);
2209             if (extension_type == QUANT_MATRIX_EXT_ID)
2210                 read_quant_matrix_ext(s, gb);
2211         }
2212     }
2213 }
2214
2215 static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2216 {
2217     MpegEncContext *s = &ctx->m;
2218     int width, height;
2219     int bits_per_raw_sample;
2220     int rgb, chroma_format;
2221
2222     // random_accessible_vol and video_object_type_indication have already
2223     // been read by the caller decode_vol_header()
2224     skip_bits(gb, 4); /* video_object_layer_verid */
2225     ctx->shape = get_bits(gb, 2); /* video_object_layer_shape */
2226     skip_bits(gb, 4); /* video_object_layer_shape_extension */
2227     skip_bits1(gb); /* progressive_sequence */
2228     if (ctx->shape != RECT_SHAPE) {
2229         avpriv_request_sample(s->avctx, "MPEG-4 Studio profile non rectangular shape");
2230         return AVERROR_PATCHWELCOME;
2231     }
2232     if (ctx->shape != BIN_ONLY_SHAPE) {
2233         rgb = get_bits1(gb); /* rgb_components */
2234         chroma_format = get_bits(gb, 2); /* chroma_format */
2235         if (!chroma_format || chroma_format == CHROMA_420 || (rgb && chroma_format == CHROMA_422)) {
2236             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
2237             return AVERROR_INVALIDDATA;
2238         }
2239
2240         bits_per_raw_sample = get_bits(gb, 4); /* bit_depth */
2241         if (bits_per_raw_sample == 10) {
2242             if (rgb) {
2243                 s->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
2244             } else {
2245                 s->avctx->pix_fmt = chroma_format == CHROMA_422 ? AV_PIX_FMT_YUV422P10 : AV_PIX_FMT_YUV444P10;
2246             }
2247         } else {
2248             avpriv_request_sample(s->avctx, "MPEG-4 Studio profile bit-depth %u", bits_per_raw_sample);
2249             return AVERROR_PATCHWELCOME;
2250         }
2251         if (rgb != ctx->rgb || s->chroma_format != chroma_format)
2252             s->context_reinit = 1;
2253         s->avctx->bits_per_raw_sample = bits_per_raw_sample;
2254         ctx->rgb = rgb;
2255         s->chroma_format = chroma_format;
2256     }
2257     if (ctx->shape == RECT_SHAPE) {
2258         check_marker(s->avctx, gb, "before video_object_layer_width");
2259         width  = get_bits(gb, 14); /* video_object_layer_width */
2260         check_marker(s->avctx, gb, "before video_object_layer_height");
2261         height = get_bits(gb, 14); /* video_object_layer_height */
2262         check_marker(s->avctx, gb, "after video_object_layer_height");
2263
2264         /* Do the same check as non-studio profile */
2265         if (width && height) {
2266             if (s->width && s->height &&
2267                 (s->width != width || s->height != height))
2268                 s->context_reinit = 1;
2269             s->width  = width;
2270             s->height = height;
2271         }
2272     }
2273     s->aspect_ratio_info = get_bits(gb, 4);
2274     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
2275         s->avctx->sample_aspect_ratio.num = get_bits(gb, 8);  // par_width
2276         s->avctx->sample_aspect_ratio.den = get_bits(gb, 8);  // par_height
2277     } else {
2278         s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[s->aspect_ratio_info];
2279     }
2280     skip_bits(gb, 4); /* frame_rate_code */
2281     skip_bits(gb, 15); /* first_half_bit_rate */
2282     check_marker(s->avctx, gb, "after first_half_bit_rate");
2283     skip_bits(gb, 15); /* latter_half_bit_rate */
2284     check_marker(s->avctx, gb, "after latter_half_bit_rate");
2285     skip_bits(gb, 15); /* first_half_vbv_buffer_size */
2286     check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
2287     skip_bits(gb, 3); /* latter_half_vbv_buffer_size */
2288     skip_bits(gb, 11); /* first_half_vbv_buffer_size */
2289     check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
2290     skip_bits(gb, 15); /* latter_half_vbv_occupancy */
2291     check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
2292     s->low_delay  = get_bits1(gb);
2293     s->mpeg_quant = get_bits1(gb); /* mpeg2_stream */
2294
2295     next_start_code_studio(gb);
2296     extension_and_user_data(s, gb, 2);
2297
2298     return 0;
2299 }
2300
2301 static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2302 {
2303     MpegEncContext *s = &ctx->m;
2304     int width, height, vo_ver_id;
2305
2306     /* vol header */
2307     skip_bits(gb, 1);                   /* random access */
2308     s->vo_type = get_bits(gb, 8);
2309
2310     /* If we are in studio profile (per vo_type), check if its all consistent
2311      * and if so continue pass control to decode_studio_vol_header().
2312      * elIf something is inconsistent, error out
2313      * else continue with (non studio) vol header decpoding.
2314      */
2315     if (s->vo_type == CORE_STUDIO_VO_TYPE ||
2316         s->vo_type == SIMPLE_STUDIO_VO_TYPE) {
2317         if (s->avctx->profile != FF_PROFILE_UNKNOWN && s->avctx->profile != FF_PROFILE_MPEG4_SIMPLE_STUDIO)
2318             return AVERROR_INVALIDDATA;
2319         s->studio_profile = 1;
2320         s->avctx->profile = FF_PROFILE_MPEG4_SIMPLE_STUDIO;
2321         return decode_studio_vol_header(ctx, gb);
2322     } else if (s->studio_profile) {
2323         return AVERROR_PATCHWELCOME;
2324     }
2325
2326     if (get_bits1(gb) != 0) {           /* is_ol_id */
2327         vo_ver_id = get_bits(gb, 4);    /* vo_ver_id */
2328         skip_bits(gb, 3);               /* vo_priority */
2329     } else {
2330         vo_ver_id = 1;
2331     }
2332     s->aspect_ratio_info = get_bits(gb, 4);
2333     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
2334         s->avctx->sample_aspect_ratio.num = get_bits(gb, 8);  // par_width
2335         s->avctx->sample_aspect_ratio.den = get_bits(gb, 8);  // par_height
2336     } else {
2337         s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[s->aspect_ratio_info];
2338     }
2339
2340     if ((ctx->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
2341         int chroma_format = get_bits(gb, 2);
2342         if (chroma_format != CHROMA_420)
2343             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
2344
2345         s->low_delay = get_bits1(gb);
2346         if (get_bits1(gb)) {    /* vbv parameters */
2347             get_bits(gb, 15);   /* first_half_bitrate */
2348             check_marker(s->avctx, gb, "after first_half_bitrate");
2349             get_bits(gb, 15);   /* latter_half_bitrate */
2350             check_marker(s->avctx, gb, "after latter_half_bitrate");
2351             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
2352             check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
2353             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
2354             get_bits(gb, 11);   /* first_half_vbv_occupancy */
2355             check_marker(s->avctx, gb, "after first_half_vbv_occupancy");
2356             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
2357             check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
2358         }
2359     } else {
2360         /* is setting low delay flag only once the smartest thing to do?
2361          * low delay detection will not be overridden. */
2362         if (s->picture_number == 0) {
2363             switch(s->vo_type) {
2364             case SIMPLE_VO_TYPE:
2365             case ADV_SIMPLE_VO_TYPE:
2366                 s->low_delay = 1;
2367                 break;
2368             default:
2369                 s->low_delay = 0;
2370             }
2371         }
2372     }
2373
2374     ctx->shape = get_bits(gb, 2); /* vol shape */
2375     if (ctx->shape != RECT_SHAPE)
2376         av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
2377     if (ctx->shape == GRAY_SHAPE && vo_ver_id != 1) {
2378         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
2379         skip_bits(gb, 4);  /* video_object_layer_shape_extension */
2380     }
2381
2382     check_marker(s->avctx, gb, "before time_increment_resolution");
2383
2384     s->avctx->framerate.num = get_bits(gb, 16);
2385     if (!s->avctx->framerate.num) {
2386         av_log(s->avctx, AV_LOG_ERROR, "framerate==0\n");
2387         return AVERROR_INVALIDDATA;
2388     }
2389
2390     ctx->time_increment_bits = av_log2(s->avctx->framerate.num - 1) + 1;
2391     if (ctx->time_increment_bits < 1)
2392         ctx->time_increment_bits = 1;
2393
2394     check_marker(s->avctx, gb, "before fixed_vop_rate");
2395
2396     if (get_bits1(gb) != 0)     /* fixed_vop_rate  */
2397         s->avctx->framerate.den = get_bits(gb, ctx->time_increment_bits);
2398     else
2399         s->avctx->framerate.den = 1;
2400
2401     s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
2402
2403     ctx->t_frame = 0;
2404
2405     if (ctx->shape != BIN_ONLY_SHAPE) {
2406         if (ctx->shape == RECT_SHAPE) {
2407             check_marker(s->avctx, gb, "before width");
2408             width = get_bits(gb, 13);
2409             check_marker(s->avctx, gb, "before height");
2410             height = get_bits(gb, 13);
2411             check_marker(s->avctx, gb, "after height");
2412             if (width && height &&  /* they should be non zero but who knows */
2413                 !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
2414                 if (s->width && s->height &&
2415                     (s->width != width || s->height != height))
2416                     s->context_reinit = 1;
2417                 s->width  = width;
2418                 s->height = height;
2419             }
2420         }
2421
2422         s->progressive_sequence  =
2423         s->progressive_frame     = get_bits1(gb) ^ 1;
2424         s->interlaced_dct        = 0;
2425         if (!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
2426             av_log(s->avctx, AV_LOG_INFO,           /* OBMC Disable */
2427                    "MPEG-4 OBMC not supported (very likely buggy encoder)\n");
2428         if (vo_ver_id == 1)
2429             ctx->vol_sprite_usage = get_bits1(gb);    /* vol_sprite_usage */
2430         else
2431             ctx->vol_sprite_usage = get_bits(gb, 2);  /* vol_sprite_usage */
2432
2433         if (ctx->vol_sprite_usage == STATIC_SPRITE)
2434             av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
2435         if (ctx->vol_sprite_usage == STATIC_SPRITE ||
2436             ctx->vol_sprite_usage == GMC_SPRITE) {
2437             if (ctx->vol_sprite_usage == STATIC_SPRITE) {
2438                 skip_bits(gb, 13); // sprite_width
2439                 check_marker(s->avctx, gb, "after sprite_width");
2440                 skip_bits(gb, 13); // sprite_height
2441                 check_marker(s->avctx, gb, "after sprite_height");
2442                 skip_bits(gb, 13); // sprite_left
2443                 check_marker(s->avctx, gb, "after sprite_left");
2444                 skip_bits(gb, 13); // sprite_top
2445                 check_marker(s->avctx, gb, "after sprite_top");
2446             }
2447             ctx->num_sprite_warping_points = get_bits(gb, 6);
2448             if (ctx->num_sprite_warping_points > 3) {
2449                 av_log(s->avctx, AV_LOG_ERROR,
2450                        "%d sprite_warping_points\n",
2451                        ctx->num_sprite_warping_points);
2452                 ctx->num_sprite_warping_points = 0;
2453                 return AVERROR_INVALIDDATA;
2454             }
2455             s->sprite_warping_accuracy  = get_bits(gb, 2);
2456             ctx->sprite_brightness_change = get_bits1(gb);
2457             if (ctx->vol_sprite_usage == STATIC_SPRITE)
2458                 skip_bits1(gb); // low_latency_sprite
2459         }
2460         // FIXME sadct disable bit if verid!=1 && shape not rect
2461
2462         if (get_bits1(gb) == 1) {                   /* not_8_bit */
2463             s->quant_precision = get_bits(gb, 4);   /* quant_precision */
2464             if (get_bits(gb, 4) != 8)               /* bits_per_pixel */
2465                 av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
2466             if (s->quant_precision != 5)
2467                 av_log(s->avctx, AV_LOG_ERROR,
2468                        "quant precision %d\n", s->quant_precision);
2469             if (s->quant_precision<3 || s->quant_precision>9) {
2470                 s->quant_precision = 5;
2471             }
2472         } else {
2473             s->quant_precision = 5;
2474         }
2475
2476         // FIXME a bunch of grayscale shape things
2477
2478         if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
2479             int i, v;
2480
2481             mpeg4_load_default_matrices(s);
2482
2483             /* load custom intra matrix */
2484             if (get_bits1(gb)) {
2485                 int last = 0;
2486                 for (i = 0; i < 64; i++) {
2487                     int j;
2488                     if (get_bits_left(gb) < 8) {
2489                         av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
2490                         return AVERROR_INVALIDDATA;
2491                     }
2492                     v = get_bits(gb, 8);
2493                     if (v == 0)
2494                         break;
2495
2496                     last = v;
2497                     j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2498                     s->intra_matrix[j]        = last;
2499                     s->chroma_intra_matrix[j] = last;
2500                 }
2501
2502                 /* replicate last value */
2503                 for (; i < 64; i++) {
2504                     int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2505                     s->intra_matrix[j]        = last;
2506                     s->chroma_intra_matrix[j] = last;
2507                 }
2508             }
2509
2510             /* load custom non intra matrix */
2511             if (get_bits1(gb)) {
2512                 int last = 0;
2513                 for (i = 0; i < 64; i++) {
2514                     int j;
2515                     if (get_bits_left(gb) < 8) {
2516                         av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
2517                         return AVERROR_INVALIDDATA;
2518                     }
2519                     v = get_bits(gb, 8);
2520                     if (v == 0)
2521                         break;
2522
2523                     last = v;
2524                     j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2525                     s->inter_matrix[j]        = v;
2526                     s->chroma_inter_matrix[j] = v;
2527                 }
2528
2529                 /* replicate last value */
2530                 for (; i < 64; i++) {
2531                     int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2532                     s->inter_matrix[j]        = last;
2533                     s->chroma_inter_matrix[j] = last;
2534                 }
2535             }
2536
2537             // FIXME a bunch of grayscale shape things
2538         }
2539
2540         if (vo_ver_id != 1)
2541             s->quarter_sample = get_bits1(gb);
2542         else
2543             s->quarter_sample = 0;
2544
2545         if (get_bits_left(gb) < 4) {
2546             av_log(s->avctx, AV_LOG_ERROR, "VOL Header truncated\n");
2547             return AVERROR_INVALIDDATA;
2548         }
2549
2550         if (!get_bits1(gb)) {
2551             int pos               = get_bits_count(gb);
2552             int estimation_method = get_bits(gb, 2);
2553             if (estimation_method < 2) {
2554                 if (!get_bits1(gb)) {
2555                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* opaque */
2556                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* transparent */
2557                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* intra_cae */
2558                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* inter_cae */
2559                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* no_update */
2560                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* upsampling */
2561                 }
2562                 if (!get_bits1(gb)) {
2563                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* intra_blocks */
2564                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* inter_blocks */
2565                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* inter4v_blocks */
2566                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* not coded blocks */
2567                 }
2568                 if (!check_marker(s->avctx, gb, "in complexity estimation part 1")) {
2569                     skip_bits_long(gb, pos - get_bits_count(gb));
2570                     goto no_cplx_est;
2571                 }
2572                 if (!get_bits1(gb)) {
2573                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* dct_coeffs */
2574                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* dct_lines */
2575                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* vlc_syms */
2576                     ctx->cplx_estimation_trash_i += 4 * get_bits1(gb);  /* vlc_bits */
2577                 }
2578                 if (!get_bits1(gb)) {
2579                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* apm */
2580                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* npm */
2581                     ctx->cplx_estimation_trash_b += 8 * get_bits1(gb);  /* interpolate_mc_q */
2582                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* forwback_mc_q */
2583                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* halfpel2 */
2584                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* halfpel4 */
2585                 }
2586                 if (!check_marker(s->avctx, gb, "in complexity estimation part 2")) {
2587                     skip_bits_long(gb, pos - get_bits_count(gb));
2588                     goto no_cplx_est;
2589                 }
2590                 if (estimation_method == 1) {
2591                     ctx->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* sadct */
2592                     ctx->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* qpel */
2593                 }
2594             } else
2595                 av_log(s->avctx, AV_LOG_ERROR,
2596                        "Invalid Complexity estimation method %d\n",
2597                        estimation_method);
2598         } else {
2599
2600 no_cplx_est:
2601             ctx->cplx_estimation_trash_i =
2602             ctx->cplx_estimation_trash_p =
2603             ctx->cplx_estimation_trash_b = 0;
2604         }
2605
2606         ctx->resync_marker = !get_bits1(gb); /* resync_marker_disabled */
2607
2608         s->data_partitioning = get_bits1(gb);
2609         if (s->data_partitioning)
2610             ctx->rvlc = get_bits1(gb);
2611
2612         if (vo_ver_id != 1) {
2613             ctx->new_pred = get_bits1(gb);
2614             if (ctx->new_pred) {
2615                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
2616                 skip_bits(gb, 2); /* requested upstream message type */
2617                 skip_bits1(gb);   /* newpred segment type */
2618             }
2619             if (get_bits1(gb)) // reduced_res_vop
2620                 av_log(s->avctx, AV_LOG_ERROR,
2621                        "reduced resolution VOP not supported\n");
2622         } else {
2623             ctx->new_pred = 0;
2624         }
2625
2626         ctx->scalability = get_bits1(gb);
2627
2628         if (ctx->scalability) {
2629             GetBitContext bak = *gb;
2630             int h_sampling_factor_n;
2631             int h_sampling_factor_m;
2632             int v_sampling_factor_n;
2633             int v_sampling_factor_m;
2634
2635             skip_bits1(gb);    // hierarchy_type
2636             skip_bits(gb, 4);  /* ref_layer_id */
2637             skip_bits1(gb);    /* ref_layer_sampling_dir */
2638             h_sampling_factor_n = get_bits(gb, 5);
2639             h_sampling_factor_m = get_bits(gb, 5);
2640             v_sampling_factor_n = get_bits(gb, 5);
2641             v_sampling_factor_m = get_bits(gb, 5);
2642             ctx->enhancement_type = get_bits1(gb);
2643
2644             if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
2645                 v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2646                 /* illegal scalability header (VERY broken encoder),
2647                  * trying to workaround */
2648                 ctx->scalability = 0;
2649                 *gb            = bak;
2650             } else
2651                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
2652
2653             // bin shape stuff FIXME
2654         }
2655     }
2656
2657     if (s->avctx->debug&FF_DEBUG_PICT_INFO) {
2658         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",
2659                s->avctx->framerate.den, s->avctx->framerate.num,
2660                ctx->time_increment_bits,
2661                s->quant_precision,
2662                s->progressive_sequence,
2663                s->low_delay,
2664                ctx->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "",
2665                s->data_partitioning ? "partition " : "", ctx->rvlc ? "rvlc " : ""
2666         );
2667     }
2668
2669     return 0;
2670 }
2671
2672 /**
2673  * Decode the user data stuff in the header.
2674  * Also initializes divx/xvid/lavc_version/build.
2675  */
2676 static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
2677 {
2678     MpegEncContext *s = &ctx->m;
2679     char buf[256];
2680     int i;
2681     int e;
2682     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
2683     char last;
2684
2685     for (i = 0; i < 255 && get_bits_count(gb) < gb->size_in_bits; i++) {
2686         if (show_bits(gb, 23) == 0)
2687             break;
2688         buf[i] = get_bits(gb, 8);
2689     }
2690     buf[i] = 0;
2691
2692     /* divx detection */
2693     e = sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
2694     if (e < 2)
2695         e = sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
2696     if (e >= 2) {
2697         ctx->divx_version = ver;
2698         ctx->divx_build   = build;
2699         s->divx_packed  = e == 3 && last == 'p';
2700     }
2701
2702     /* libavcodec detection */
2703     e = sscanf(buf, "FFmpe%*[^b]b%d", &build) + 3;
2704     if (e != 4)
2705         e = sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
2706     if (e != 4) {
2707         e = sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1;
2708         if (e > 1) {
2709             if (ver > 0xFFU || ver2 > 0xFFU || ver3 > 0xFFU) {
2710                 av_log(s->avctx, AV_LOG_WARNING,
2711                      "Unknown Lavc version string encountered, %d.%d.%d; "
2712                      "clamping sub-version values to 8-bits.\n",
2713                      ver, ver2, ver3);
2714             }
2715             build = ((ver & 0xFF) << 16) + ((ver2 & 0xFF) << 8) + (ver3 & 0xFF);
2716         }
2717     }
2718     if (e != 4) {
2719         if (strcmp(buf, "ffmpeg") == 0)
2720             ctx->lavc_build = 4600;
2721     }
2722     if (e == 4)
2723         ctx->lavc_build = build;
2724
2725     /* Xvid detection */
2726     e = sscanf(buf, "XviD%d", &build);
2727     if (e == 1)
2728         ctx->xvid_build = build;
2729
2730     return 0;
2731 }
2732
2733 int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
2734 {
2735     Mpeg4DecContext *ctx = avctx->priv_data;
2736     MpegEncContext *s = &ctx->m;
2737
2738     if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
2739         if (s->codec_tag        == AV_RL32("XVID") ||
2740             s->codec_tag        == AV_RL32("XVIX") ||
2741             s->codec_tag        == AV_RL32("RMP4") ||
2742             s->codec_tag        == AV_RL32("ZMP4") ||
2743             s->codec_tag        == AV_RL32("SIPP"))
2744             ctx->xvid_build = 0;
2745     }
2746
2747     if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
2748         if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
2749             ctx->vol_control_parameters == 0)
2750             ctx->divx_version = 400;  // divx 4
2751
2752     if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
2753         ctx->divx_version =
2754         ctx->divx_build   = -1;
2755     }
2756
2757     if (s->workaround_bugs & FF_BUG_AUTODETECT) {
2758         if (s->codec_tag == AV_RL32("XVIX"))
2759             s->workaround_bugs |= FF_BUG_XVID_ILACE;
2760
2761         if (s->codec_tag == AV_RL32("UMP4"))
2762             s->workaround_bugs |= FF_BUG_UMP4;
2763
2764         if (ctx->divx_version >= 500 && ctx->divx_build < 1814)
2765             s->workaround_bugs |= FF_BUG_QPEL_CHROMA;
2766
2767         if (ctx->divx_version > 502 && ctx->divx_build < 1814)
2768             s->workaround_bugs |= FF_BUG_QPEL_CHROMA2;
2769
2770         if (ctx->xvid_build <= 3U)
2771             s->padding_bug_score = 256 * 256 * 256 * 64;
2772
2773         if (ctx->xvid_build <= 1U)
2774             s->workaround_bugs |= FF_BUG_QPEL_CHROMA;
2775
2776         if (ctx->xvid_build <= 12U)
2777             s->workaround_bugs |= FF_BUG_EDGE;
2778
2779         if (ctx->xvid_build <= 32U)
2780             s->workaround_bugs |= FF_BUG_DC_CLIP;
2781
2782 #define SET_QPEL_FUNC(postfix1, postfix2)                           \
2783     s->qdsp.put_        ## postfix1 = ff_put_        ## postfix2;   \
2784     s->qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;   \
2785     s->qdsp.avg_        ## postfix1 = ff_avg_        ## postfix2;
2786
2787         if (ctx->lavc_build < 4653U)
2788             s->workaround_bugs |= FF_BUG_STD_QPEL;
2789
2790         if (ctx->lavc_build < 4655U)
2791             s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
2792
2793         if (ctx->lavc_build < 4670U)
2794             s->workaround_bugs |= FF_BUG_EDGE;
2795
2796         if (ctx->lavc_build <= 4712U)
2797             s->workaround_bugs |= FF_BUG_DC_CLIP;
2798
2799         if ((ctx->lavc_build&0xFF) >= 100) {
2800             if (ctx->lavc_build > 3621476 && ctx->lavc_build < 3752552 &&
2801                (ctx->lavc_build < 3752037 || ctx->lavc_build > 3752191) // 3.2.1+
2802             )
2803                 s->workaround_bugs |= FF_BUG_IEDGE;
2804         }
2805
2806         if (ctx->divx_version >= 0)
2807             s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
2808         if (ctx->divx_version == 501 && ctx->divx_build == 20020416)
2809             s->padding_bug_score = 256 * 256 * 256 * 64;
2810
2811         if (ctx->divx_version < 500U)
2812             s->workaround_bugs |= FF_BUG_EDGE;
2813
2814         if (ctx->divx_version >= 0)
2815             s->workaround_bugs |= FF_BUG_HPEL_CHROMA;
2816     }
2817
2818     if (s->workaround_bugs & FF_BUG_STD_QPEL) {
2819         SET_QPEL_FUNC(qpel_pixels_tab[0][5], qpel16_mc11_old_c)
2820         SET_QPEL_FUNC(qpel_pixels_tab[0][7], qpel16_mc31_old_c)
2821         SET_QPEL_FUNC(qpel_pixels_tab[0][9], qpel16_mc12_old_c)
2822         SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
2823         SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
2824         SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
2825
2826         SET_QPEL_FUNC(qpel_pixels_tab[1][5], qpel8_mc11_old_c)
2827         SET_QPEL_FUNC(qpel_pixels_tab[1][7], qpel8_mc31_old_c)
2828         SET_QPEL_FUNC(qpel_pixels_tab[1][9], qpel8_mc12_old_c)
2829         SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
2830         SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
2831         SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
2832     }
2833
2834     if (avctx->debug & FF_DEBUG_BUGS)
2835         av_log(s->avctx, AV_LOG_DEBUG,
2836                "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
2837                s->workaround_bugs, ctx->lavc_build, ctx->xvid_build,
2838                ctx->divx_version, ctx->divx_build, s->divx_packed ? "p" : "");
2839
2840     if (CONFIG_MPEG4_DECODER && ctx->xvid_build >= 0 &&
2841         s->codec_id == AV_CODEC_ID_MPEG4 &&
2842         avctx->idct_algo == FF_IDCT_AUTO) {
2843         avctx->idct_algo = FF_IDCT_XVID;
2844         ff_mpv_idct_init(s);
2845         return 1;
2846     }
2847
2848     return 0;
2849 }
2850
2851 static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2852 {
2853     MpegEncContext *s = &ctx->m;
2854     int time_incr, time_increment;
2855     int64_t pts;
2856
2857     s->mcsel       = 0;
2858     s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;        /* pict type: I = 0 , P = 1 */
2859     if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
2860         ctx->vol_control_parameters == 0 && !(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) {
2861         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
2862         s->low_delay = 0;
2863     }
2864
2865     s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
2866     if (s->partitioned_frame)
2867         s->decode_mb = mpeg4_decode_partitioned_mb;
2868     else
2869         s->decode_mb = mpeg4_decode_mb;
2870
2871     time_incr = 0;
2872     while (get_bits1(gb) != 0)
2873         time_incr++;
2874
2875     check_marker(s->avctx, gb, "before time_increment");
2876
2877     if (ctx->time_increment_bits == 0 ||
2878         !(show_bits(gb, ctx->time_increment_bits + 1) & 1)) {
2879         av_log(s->avctx, AV_LOG_WARNING,
2880                "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);
2881
2882         for (ctx->time_increment_bits = 1;
2883              ctx->time_increment_bits < 16;
2884              ctx->time_increment_bits++) {
2885             if (s->pict_type == AV_PICTURE_TYPE_P ||
2886                 (s->pict_type == AV_PICTURE_TYPE_S &&
2887                  ctx->vol_sprite_usage == GMC_SPRITE)) {
2888                 if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
2889                     break;
2890             } else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
2891                 break;
2892         }
2893
2894         av_log(s->avctx, AV_LOG_WARNING,
2895                "time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits);
2896         if (s->avctx->framerate.num && 4*s->avctx->framerate.num < 1<<ctx->time_increment_bits) {
2897             s->avctx->framerate.num = 1<<ctx->time_increment_bits;
2898             s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
2899         }
2900     }
2901
2902     if (IS_3IV1)
2903         time_increment = get_bits1(gb);        // FIXME investigate further
2904     else
2905         time_increment = get_bits(gb, ctx->time_increment_bits);
2906
2907     if (s->pict_type != AV_PICTURE_TYPE_B) {
2908         s->last_time_base = s->time_base;
2909         s->time_base     += time_incr;
2910         s->time = s->time_base * (int64_t)s->avctx->framerate.num + time_increment;
2911         if (s->workaround_bugs & FF_BUG_UMP4) {
2912             if (s->time < s->last_non_b_time) {
2913                 /* header is not mpeg-4-compatible, broken encoder,
2914                  * trying to workaround */
2915                 s->time_base++;
2916                 s->time += s->avctx->framerate.num;
2917             }
2918         }
2919         s->pp_time         = s->time - s->last_non_b_time;
2920         s->last_non_b_time = s->time;
2921     } else {
2922         s->time    = (s->last_time_base + time_incr) * (int64_t)s->avctx->framerate.num + time_increment;
2923         s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
2924         if (s->pp_time <= s->pb_time ||
2925             s->pp_time <= s->pp_time - s->pb_time ||
2926             s->pp_time <= 0) {
2927             /* messed up order, maybe after seeking? skipping current B-frame */
2928             return FRAME_SKIPPED;
2929         }
2930         ff_mpeg4_init_direct_mv(s);
2931
2932         if (ctx->t_frame == 0)
2933             ctx->t_frame = s->pb_time;
2934         if (ctx->t_frame == 0)
2935             ctx->t_frame = 1;  // 1/0 protection
2936         s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, ctx->t_frame) -
2937                             ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
2938         s->pb_field_time = (ROUNDED_DIV(s->time, ctx->t_frame) -
2939                             ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
2940         if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) {
2941             s->pb_field_time = 2;
2942             s->pp_field_time = 4;
2943             if (!s->progressive_sequence)
2944                 return FRAME_SKIPPED;
2945         }
2946     }
2947
2948     if (s->avctx->framerate.den)
2949         pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
2950     else
2951         pts = AV_NOPTS_VALUE;
2952     ff_dlog(s->avctx, "MPEG4 PTS: %"PRId64"\n", pts);
2953
2954     check_marker(s->avctx, gb, "before vop_coded");
2955
2956     /* vop coded */
2957     if (get_bits1(gb) != 1) {
2958         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2959             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
2960         return FRAME_SKIPPED;
2961     }
2962     if (ctx->new_pred)
2963         decode_new_pred(ctx, gb);
2964
2965     if (ctx->shape != BIN_ONLY_SHAPE &&
2966                     (s->pict_type == AV_PICTURE_TYPE_P ||
2967                      (s->pict_type == AV_PICTURE_TYPE_S &&
2968                       ctx->vol_sprite_usage == GMC_SPRITE))) {
2969         /* rounding type for motion estimation */
2970         s->no_rounding = get_bits1(gb);
2971     } else {
2972         s->no_rounding = 0;
2973     }
2974     // FIXME reduced res stuff
2975
2976     if (ctx->shape != RECT_SHAPE) {
2977         if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
2978             skip_bits(gb, 13);  /* width */
2979             check_marker(s->avctx, gb, "after width");
2980             skip_bits(gb, 13);  /* height */
2981             check_marker(s->avctx, gb, "after height");
2982             skip_bits(gb, 13);  /* hor_spat_ref */
2983             check_marker(s->avctx, gb, "after hor_spat_ref");
2984             skip_bits(gb, 13);  /* ver_spat_ref */
2985         }
2986         skip_bits1(gb);         /* change_CR_disable */
2987
2988         if (get_bits1(gb) != 0)
2989             skip_bits(gb, 8);   /* constant_alpha_value */
2990     }
2991
2992     // FIXME complexity estimation stuff
2993
2994     if (ctx->shape != BIN_ONLY_SHAPE) {
2995         skip_bits_long(gb, ctx->cplx_estimation_trash_i);
2996         if (s->pict_type != AV_PICTURE_TYPE_I)
2997             skip_bits_long(gb, ctx->cplx_estimation_trash_p);
2998         if (s->pict_type == AV_PICTURE_TYPE_B)
2999             skip_bits_long(gb, ctx->cplx_estimation_trash_b);
3000
3001         if (get_bits_left(gb) < 3) {
3002             av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
3003             return AVERROR_INVALIDDATA;
3004         }
3005         ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
3006         if (!s->progressive_sequence) {
3007             s->top_field_first = get_bits1(gb);
3008             s->alternate_scan  = get_bits1(gb);
3009         } else
3010             s->alternate_scan = 0;
3011     }
3012
3013     if (s->alternate_scan) {
3014         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
3015         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
3016         ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
3017         ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
3018     } else {
3019         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
3020         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
3021         ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
3022         ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
3023     }
3024
3025     if (s->pict_type == AV_PICTURE_TYPE_S) {
3026         if((ctx->vol_sprite_usage == STATIC_SPRITE ||
3027             ctx->vol_sprite_usage == GMC_SPRITE)) {
3028             if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
3029                 return AVERROR_INVALIDDATA;
3030             if (ctx->sprite_brightness_change)
3031                 av_log(s->avctx, AV_LOG_ERROR,
3032                     "sprite_brightness_change not supported\n");
3033             if (ctx->vol_sprite_usage == STATIC_SPRITE)
3034                 av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
3035         } else {
3036             memset(s->sprite_offset, 0, sizeof(s->sprite_offset));
3037             memset(s->sprite_delta, 0, sizeof(s->sprite_delta));
3038         }
3039     }
3040
3041     if (ctx->shape != BIN_ONLY_SHAPE) {
3042         s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
3043         if (s->qscale == 0) {
3044             av_log(s->avctx, AV_LOG_ERROR,
3045                    "Error, header damaged or not MPEG-4 header (qscale=0)\n");
3046             return AVERROR_INVALIDDATA;  // makes no sense to continue, as there is nothing left from the image then
3047         }
3048
3049         if (s->pict_type != AV_PICTURE_TYPE_I) {
3050             s->f_code = get_bits(gb, 3);        /* fcode_for */
3051             if (s->f_code == 0) {
3052                 av_log(s->avctx, AV_LOG_ERROR,
3053                        "Error, header damaged or not MPEG-4 header (f_code=0)\n");
3054                 s->f_code = 1;
3055                 return AVERROR_INVALIDDATA;  // makes no sense to continue, as there is nothing left from the image then
3056             }
3057         } else
3058             s->f_code = 1;
3059
3060         if (s->pict_type == AV_PICTURE_TYPE_B) {
3061             s->b_code = get_bits(gb, 3);
3062             if (s->b_code == 0) {
3063                 av_log(s->avctx, AV_LOG_ERROR,
3064                        "Error, header damaged or not MPEG4 header (b_code=0)\n");
3065                 s->b_code=1;
3066                 return AVERROR_INVALIDDATA; // makes no sense to continue, as the MV decoding will break very quickly
3067             }
3068         } else
3069             s->b_code = 1;
3070
3071         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
3072             av_log(s->avctx, AV_LOG_DEBUG,
3073                    "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",
3074                    s->qscale, s->f_code, s->b_code,
3075                    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")),
3076                    gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
3077                    s->top_field_first, s->quarter_sample ? "q" : "h",
3078                    s->data_partitioning, ctx->resync_marker,
3079                    ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
3080                    1 - s->no_rounding, s->vo_type,
3081                    ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
3082                    ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
3083                    ctx->cplx_estimation_trash_b,
3084                    s->time,
3085                    time_increment
3086                   );
3087         }
3088
3089         if (!ctx->scalability) {
3090             if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
3091                 skip_bits1(gb);  // vop shape coding type
3092         } else {
3093             if (ctx->enhancement_type) {
3094                 int load_backward_shape = get_bits1(gb);
3095                 if (load_backward_shape)
3096                     av_log(s->avctx, AV_LOG_ERROR,
3097                            "load backward shape isn't supported\n");
3098             }
3099             skip_bits(gb, 2);  // ref_select_code
3100         }
3101     }
3102     /* detect buggy encoders which don't set the low_delay flag
3103      * (divx4/xvid/opendivx). Note we cannot detect divx5 without B-frames
3104      * easily (although it's buggy too) */
3105     if (s->vo_type == 0 && ctx->vol_control_parameters == 0 &&
3106         ctx->divx_version == -1 && s->picture_number == 0) {
3107         av_log(s->avctx, AV_LOG_WARNING,
3108                "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
3109         s->low_delay = 1;
3110     }
3111
3112     s->picture_number++;  // better than pic number==0 always ;)
3113
3114     // FIXME add short header support
3115     s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
3116     s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;
3117
3118     if (s->workaround_bugs & FF_BUG_EDGE) {
3119         s->h_edge_pos = s->width;
3120         s->v_edge_pos = s->height;
3121     }
3122     return 0;
3123 }
3124
3125 static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
3126 {
3127     MpegEncContext *s = &ctx->m;
3128
3129     skip_bits(gb, 16); /* Time_code[63..48] */
3130     check_marker(s->avctx, gb, "after Time_code[63..48]");
3131     skip_bits(gb, 16); /* Time_code[47..32] */
3132     check_marker(s->avctx, gb, "after Time_code[47..32]");
3133     skip_bits(gb, 16); /* Time_code[31..16] */
3134     check_marker(s->avctx, gb, "after Time_code[31..16]");
3135     skip_bits(gb, 16); /* Time_code[15..0] */
3136     check_marker(s->avctx, gb, "after Time_code[15..0]");
3137     skip_bits(gb, 4); /* reserved_bits */
3138 }
3139
3140 /**
3141  * Decode the next studio vop header.
3142  * @return <0 if something went wrong
3143  */
3144 static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
3145 {
3146     MpegEncContext *s = &ctx->m;
3147
3148     if (get_bits_left(gb) <= 32)
3149         return 0;
3150
3151     s->partitioned_frame = 0;
3152     s->interlaced_dct = 0;
3153     s->decode_mb = mpeg4_decode_studio_mb;
3154
3155     decode_smpte_tc(ctx, gb);
3156
3157     skip_bits(gb, 10); /* temporal_reference */
3158     skip_bits(gb, 2); /* vop_structure */
3159     s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* vop_coding_type */
3160     if (get_bits1(gb)) { /* vop_coded */
3161         skip_bits1(gb); /* top_field_first */
3162         skip_bits1(gb); /* repeat_first_field */
3163         s->progressive_frame = get_bits1(gb) ^ 1; /* progressive_frame */
3164     }
3165
3166     if (s->pict_type == AV_PICTURE_TYPE_I) {
3167         if (get_bits1(gb))
3168             reset_studio_dc_predictors(s);
3169     }
3170
3171     if (ctx->shape != BIN_ONLY_SHAPE) {
3172         s->alternate_scan = get_bits1(gb);
3173         s->frame_pred_frame_dct = get_bits1(gb);
3174         s->dct_precision = get_bits(gb, 2);
3175         s->intra_dc_precision = get_bits(gb, 2);
3176         s->q_scale_type = get_bits1(gb);
3177     }
3178
3179     if (s->alternate_scan) {
3180         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
3181         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
3182         ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
3183         ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
3184     } else {
3185         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
3186         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
3187         ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
3188         ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
3189     }
3190
3191     mpeg4_load_default_matrices(s);
3192
3193     next_start_code_studio(gb);
3194     extension_and_user_data(s, gb, 4);
3195
3196     return 0;
3197 }
3198
3199 static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb)
3200 {
3201     MpegEncContext *s = &ctx->m;
3202     int visual_object_type;
3203
3204     skip_bits(gb, 4); /* visual_object_verid */
3205     visual_object_type = get_bits(gb, 4);
3206     if (visual_object_type != VOT_VIDEO_ID) {
3207         avpriv_request_sample(s->avctx, "VO type %u", visual_object_type);
3208         return AVERROR_PATCHWELCOME;
3209     }
3210
3211     next_start_code_studio(gb);
3212     extension_and_user_data(s, gb, 1);
3213
3214     return 0;
3215 }
3216
3217 /**
3218  * Decode MPEG-4 headers.
3219  *
3220  * @param  header If set the absence of a VOP is not treated as error; otherwise, it is treated as such.
3221  * @return <0 if an error occurred
3222  *         FRAME_SKIPPED if a not coded VOP is found
3223  *         0 else
3224  */
3225 int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header)
3226 {
3227     MpegEncContext *s = &ctx->m;
3228     unsigned startcode, v;
3229     int ret;
3230     int vol = 0;
3231
3232     /* search next start code */
3233     align_get_bits(gb);
3234
3235     // If we have not switched to studio profile than we also did not switch bps
3236     // that means something else (like a previous instance) outside set bps which
3237     // would be inconsistant with the currect state, thus reset it
3238     if (!s->studio_profile && s->avctx->bits_per_raw_sample != 8)
3239         s->avctx->bits_per_raw_sample = 0;
3240
3241     if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
3242         skip_bits(gb, 24);
3243         if (get_bits(gb, 8) == 0xF0)
3244             goto end;
3245     }
3246
3247     startcode = 0xff;
3248     for (;;) {
3249         if (get_bits_count(gb) >= gb->size_in_bits) {
3250             if (gb->size_in_bits == 8 &&
3251                 (ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
3252                 av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
3253                 return FRAME_SKIPPED;  // divx bug
3254             } else if (header && get_bits_count(gb) == gb->size_in_bits) {
3255                 return 0; // ordinary return value for parsing of extradata
3256             } else
3257                 return AVERROR_INVALIDDATA;  // end of stream
3258         }
3259
3260         /* use the bits after the test */
3261         v = get_bits(gb, 8);
3262         startcode = ((startcode << 8) | v) & 0xffffffff;
3263
3264         if ((startcode & 0xFFFFFF00) != 0x100)
3265             continue;  // no startcode
3266
3267         if (s->avctx->debug & FF_DEBUG_STARTCODE) {
3268             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
3269             if (startcode <= 0x11F)
3270                 av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
3271             else if (startcode <= 0x12F)
3272                 av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
3273             else if (startcode <= 0x13F)
3274                 av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
3275             else if (startcode <= 0x15F)
3276                 av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
3277             else if (startcode <= 0x1AF)
3278                 av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
3279             else if (startcode == 0x1B0)
3280                 av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
3281             else if (startcode == 0x1B1)
3282                 av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
3283             else if (startcode == 0x1B2)
3284                 av_log(s->avctx, AV_LOG_DEBUG, "User Data");
3285             else if (startcode == 0x1B3)
3286                 av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
3287             else if (startcode == 0x1B4)
3288                 av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
3289             else if (startcode == 0x1B5)
3290                 av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
3291             else if (startcode == 0x1B6)
3292                 av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
3293             else if (startcode == 0x1B7)
3294                 av_log(s->avctx, AV_LOG_DEBUG, "slice start");
3295             else if (startcode == 0x1B8)
3296                 av_log(s->avctx, AV_LOG_DEBUG, "extension start");
3297             else if (startcode == 0x1B9)
3298                 av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
3299             else if (startcode == 0x1BA)
3300                 av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
3301             else if (startcode == 0x1BB)
3302                 av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
3303             else if (startcode == 0x1BC)
3304                 av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
3305             else if (startcode == 0x1BD)
3306                 av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
3307             else if (startcode == 0x1BE)
3308                 av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
3309             else if (startcode == 0x1BF)
3310                 av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
3311             else if (startcode == 0x1C0)
3312                 av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
3313             else if (startcode == 0x1C1)
3314                 av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
3315             else if (startcode == 0x1C2)
3316                 av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
3317             else if (startcode == 0x1C3)
3318                 av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
3319             else if (startcode <= 0x1C5)
3320                 av_log(s->avctx, AV_LOG_DEBUG, "reserved");
3321             else if (startcode <= 0x1FF)
3322                 av_log(s->avctx, AV_LOG_DEBUG, "System start");
3323             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
3324         }
3325
3326         if (startcode >= 0x120 && startcode <= 0x12F) {
3327             if (vol) {
3328                 av_log(s->avctx, AV_LOG_WARNING, "Ignoring multiple VOL headers\n");
3329                 continue;
3330             }
3331             vol++;
3332             if ((ret = decode_vol_header(ctx, gb)) < 0)
3333                 return ret;
3334         } else if (startcode == USER_DATA_STARTCODE) {
3335             decode_user_data(ctx, gb);
3336         } else if (startcode == GOP_STARTCODE) {
3337             mpeg4_decode_gop_header(s, gb);
3338         } else if (startcode == VOS_STARTCODE) {
3339             int profile, level;
3340             mpeg4_decode_profile_level(s, gb, &profile, &level);
3341             if (profile == FF_PROFILE_MPEG4_SIMPLE_STUDIO &&
3342                 (level > 0 && level < 9)) {
3343                 s->studio_profile = 1;
3344                 next_start_code_studio(gb);
3345                 extension_and_user_data(s, gb, 0);
3346             } else if (s->studio_profile) {
3347                 avpriv_request_sample(s->avctx, "Mix of studio and non studio profile");
3348                 return AVERROR_PATCHWELCOME;
3349             }
3350             s->avctx->profile = profile;
3351             s->avctx->level   = level;
3352         } else if (startcode == VISUAL_OBJ_STARTCODE) {
3353             if (s->studio_profile) {
3354                 if ((ret = decode_studiovisualobject(ctx, gb)) < 0)
3355                     return ret;
3356             } else
3357                 mpeg4_decode_visual_object(s, gb);
3358         } else if (startcode == VOP_STARTCODE) {
3359             break;
3360         }
3361
3362         align_get_bits(gb);
3363         startcode = 0xff;
3364     }
3365
3366 end:
3367     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
3368         s->low_delay = 1;
3369     s->avctx->has_b_frames = !s->low_delay;
3370
3371     if (s->studio_profile) {
3372         if (!s->avctx->bits_per_raw_sample) {
3373             av_log(s->avctx, AV_LOG_ERROR, "Missing VOL header\n");
3374             return AVERROR_INVALIDDATA;
3375         }
3376         return decode_studio_vop_header(ctx, gb);
3377     } else
3378         return decode_vop_header(ctx, gb);
3379 }
3380
3381 av_cold void ff_mpeg4videodec_static_init(void) {
3382     static int done = 0;
3383
3384     if (!done) {
3385         ff_rl_init(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
3386         ff_rl_init(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
3387         ff_rl_init(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
3388         INIT_FIRST_VLC_RL(ff_mpeg4_rl_intra, 554);
3389         INIT_VLC_RL(ff_rvlc_rl_inter, 1072);
3390         INIT_FIRST_VLC_RL(ff_rvlc_rl_intra, 1072);
3391         INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
3392                         &ff_mpeg4_DCtab_lum[0][1], 2, 1,
3393                         &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
3394         INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
3395                         &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
3396                         &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
3397         INIT_VLC_STATIC_FROM_LENGTHS(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3398                                      ff_sprite_trajectory_lens, 1,
3399                                      NULL, 0, 0, 0, 0, 128);
3400         INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3401                         &ff_mb_type_b_tab[0][1], 2, 1,
3402                         &ff_mb_type_b_tab[0][0], 2, 1, 16);
3403         done = 1;
3404     }
3405 }
3406
3407 int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
3408 {
3409     Mpeg4DecContext *ctx = avctx->priv_data;
3410     MpegEncContext    *s = &ctx->m;
3411
3412     /* divx 5.01+ bitstream reorder stuff */
3413     /* Since this clobbers the input buffer and hwaccel codecs still need the
3414      * data during hwaccel->end_frame we should not do this any earlier */
3415     if (s->divx_packed) {
3416         int current_pos     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);
3417         int startcode_found = 0;
3418
3419         if (buf_size - current_pos > 7) {
3420
3421             int i;
3422             for (i = current_pos; i < buf_size - 4; i++)
3423
3424                 if (buf[i]     == 0 &&
3425                     buf[i + 1] == 0 &&
3426                     buf[i + 2] == 1 &&
3427                     buf[i + 3] == 0xB6) {
3428                     startcode_found = !(buf[i + 4] & 0x40);
3429                     break;
3430                 }
3431         }
3432
3433         if (startcode_found) {
3434             if (!ctx->showed_packed_warning) {
3435                 av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and "
3436                        "wasteful way to store B-frames ('packed B-frames'). "
3437                        "Consider using the mpeg4_unpack_bframes bitstream filter without encoding but stream copy to fix it.\n");
3438                 ctx->showed_packed_warning = 1;
3439             }
3440             av_fast_padded_malloc(&s->bitstream_buffer,
3441                            &s->allocated_bitstream_buffer_size,
3442                            buf_size - current_pos);
3443             if (!s->bitstream_buffer) {
3444                 s->bitstream_buffer_size = 0;
3445                 return AVERROR(ENOMEM);
3446             }
3447             memcpy(s->bitstream_buffer, buf + current_pos,
3448                    buf_size - current_pos);
3449             s->bitstream_buffer_size = buf_size - current_pos;
3450         }
3451     }
3452
3453     return 0;
3454 }
3455
3456 #if HAVE_THREADS
3457 static int mpeg4_update_thread_context(AVCodecContext *dst,
3458                                        const AVCodecContext *src)
3459 {
3460     Mpeg4DecContext *s = dst->priv_data;
3461     const Mpeg4DecContext *s1 = src->priv_data;
3462     int init = s->m.context_initialized;
3463
3464     int ret = ff_mpeg_update_thread_context(dst, src);
3465
3466     if (ret < 0)
3467         return ret;
3468
3469     // copy all the necessary fields explicitly
3470     s->time_increment_bits       = s1->time_increment_bits;
3471     s->shape                     = s1->shape;
3472     s->vol_sprite_usage          = s1->vol_sprite_usage;
3473     s->sprite_brightness_change  = s1->sprite_brightness_change;
3474     s->num_sprite_warping_points = s1->num_sprite_warping_points;
3475     s->rvlc                      = s1->rvlc;
3476     s->resync_marker             = s1->resync_marker;
3477     s->t_frame                   = s1->t_frame;
3478     s->new_pred                  = s1->new_pred;
3479     s->enhancement_type          = s1->enhancement_type;
3480     s->scalability               = s1->scalability;
3481     s->use_intra_dc_vlc          = s1->use_intra_dc_vlc;
3482     s->intra_dc_threshold        = s1->intra_dc_threshold;
3483     s->divx_version              = s1->divx_version;
3484     s->divx_build                = s1->divx_build;
3485     s->xvid_build                = s1->xvid_build;
3486     s->lavc_build                = s1->lavc_build;
3487     s->showed_packed_warning     = s1->showed_packed_warning;
3488     s->vol_control_parameters    = s1->vol_control_parameters;
3489     s->cplx_estimation_trash_i   = s1->cplx_estimation_trash_i;
3490     s->cplx_estimation_trash_p   = s1->cplx_estimation_trash_p;
3491     s->cplx_estimation_trash_b   = s1->cplx_estimation_trash_b;
3492     s->rgb                       = s1->rgb;
3493
3494     memcpy(s->sprite_shift, s1->sprite_shift, sizeof(s1->sprite_shift));
3495     memcpy(s->sprite_traj,  s1->sprite_traj,  sizeof(s1->sprite_traj));
3496
3497     if (CONFIG_MPEG4_DECODER && !init && s1->xvid_build >= 0)
3498         ff_xvid_idct_init(&s->m.idsp, dst);
3499
3500     return 0;
3501 }
3502 #endif
3503
3504 static av_cold void mpeg4_init_static(void)
3505 {
3506     INIT_VLC_STATIC_FROM_LENGTHS(&studio_luma_dc, STUDIO_INTRA_BITS, 19,
3507                                  &ff_mpeg4_studio_dc_luma[0][1], 2,
3508                                  &ff_mpeg4_studio_dc_luma[0][0], 2, 1,
3509                                  0, 0, 528);
3510
3511     INIT_VLC_STATIC_FROM_LENGTHS(&studio_chroma_dc, STUDIO_INTRA_BITS, 19,
3512                                  &ff_mpeg4_studio_dc_chroma[0][1], 2,
3513                                  &ff_mpeg4_studio_dc_chroma[0][0], 2, 1,
3514                                  0, 0, 528);
3515
3516     for (unsigned i = 0, offset = 0; i < 12; i++) {
3517         static VLC_TYPE vlc_buf[6498][2];
3518
3519         studio_intra_tab[i].table           = &vlc_buf[offset];
3520         studio_intra_tab[i].table_allocated = FF_ARRAY_ELEMS(vlc_buf) - offset;
3521         ff_init_vlc_from_lengths(&studio_intra_tab[i],
3522                                  STUDIO_INTRA_BITS, 24,
3523                                  &ff_mpeg4_studio_intra[i][0][1], 2,
3524                                  &ff_mpeg4_studio_intra[i][0][0], 2, 1,
3525                                  0, INIT_VLC_STATIC_OVERLONG, NULL);
3526         offset += studio_intra_tab[i].table_size;
3527     }
3528     ff_mpeg4videodec_static_init();
3529 }
3530
3531 static av_cold int decode_init(AVCodecContext *avctx)
3532 {
3533     static AVOnce init_static_once = AV_ONCE_INIT;
3534     Mpeg4DecContext *ctx = avctx->priv_data;
3535     MpegEncContext *s = &ctx->m;
3536     int ret;
3537
3538     ctx->divx_version =
3539     ctx->divx_build   =
3540     ctx->xvid_build   =
3541     ctx->lavc_build   = -1;
3542
3543     if ((ret = ff_h263_decode_init(avctx)) < 0)
3544         return ret;
3545
3546     s->h263_pred = 1;
3547     s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
3548     s->decode_mb = mpeg4_decode_mb;
3549     ctx->time_increment_bits = 4; /* default value for broken headers */
3550
3551     avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
3552
3553     ff_thread_once(&init_static_once, mpeg4_init_static);
3554
3555     return 0;
3556 }
3557
3558 static const AVOption mpeg4_options[] = {
3559     {"quarter_sample", "1/4 subpel MC", offsetof(MpegEncContext, quarter_sample), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
3560     {"divx_packed", "divx style packed b frames", offsetof(MpegEncContext, divx_packed), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
3561     {NULL}
3562 };
3563
3564 static const AVClass mpeg4_class = {
3565     .class_name = "MPEG4 Video Decoder",
3566     .item_name  = av_default_item_name,
3567     .option     = mpeg4_options,
3568     .version    = LIBAVUTIL_VERSION_INT,
3569 };
3570
3571 AVCodec ff_mpeg4_decoder = {
3572     .name                  = "mpeg4",
3573     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
3574     .type                  = AVMEDIA_TYPE_VIDEO,
3575     .id                    = AV_CODEC_ID_MPEG4,
3576     .priv_data_size        = sizeof(Mpeg4DecContext),
3577     .init                  = decode_init,
3578     .close                 = ff_h263_decode_end,
3579     .decode                = ff_h263_decode_frame,
3580     .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
3581                              AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
3582                              AV_CODEC_CAP_FRAME_THREADS,
3583     .caps_internal         = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
3584                              FF_CODEC_CAP_ALLOCATE_PROGRESS |
3585                              FF_CODEC_CAP_INIT_CLEANUP,
3586     .flush                 = ff_mpeg_flush,
3587     .max_lowres            = 3,
3588     .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
3589     .profiles              = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles),
3590     .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg4_update_thread_context),
3591     .priv_class = &mpeg4_class,
3592     .hw_configs            = (const AVCodecHWConfigInternal *const []) {
3593 #if CONFIG_MPEG4_NVDEC_HWACCEL
3594                                HWACCEL_NVDEC(mpeg4),
3595 #endif
3596 #if CONFIG_MPEG4_VAAPI_HWACCEL
3597                                HWACCEL_VAAPI(mpeg4),
3598 #endif
3599 #if CONFIG_MPEG4_VDPAU_HWACCEL
3600                                HWACCEL_VDPAU(mpeg4),
3601 #endif
3602 #if CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL
3603                                HWACCEL_VIDEOTOOLBOX(mpeg4),
3604 #endif
3605                                NULL
3606                            },
3607 };