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

   1 /*
   2  * MPEG4 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/opt.h"
  26 #include "error_resilience.h"
  27 #include "internal.h"
  28 #include "mpegvideo.h"
  29 #include "mpeg4video.h"
  30 #include "h263.h"
  31 #include "thread.h"
  32
  33 /* The defines below define the number of bits that are read at once for
  34  * reading vlc values. Changing these may improve speed and data cache needs
  35  * be aware though that decreasing them may need the number of stages that is
  36  * passed to get_vlc* to be increased. */
  37 #define SPRITE_TRAJ_VLC_BITS 6
  38 #define DC_VLC_BITS 9
  39 #define MB_TYPE_B_VLC_BITS 4
  40
  41 static VLC dc_lum, dc_chrom;
  42 static VLC sprite_trajectory;
  43 static VLC mb_type_b_vlc;
  44
  45 static const int mb_type_b_map[4] = {
  46     MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
  47     MB_TYPE_L0L1    | MB_TYPE_16x16,
  48     MB_TYPE_L1      | MB_TYPE_16x16,
  49     MB_TYPE_L0      | MB_TYPE_16x16,
  50 };
  51
  52 /**
  53  * Predict the ac.
  54  * @param n block index (0-3 are luma, 4-5 are chroma)
  55  * @param dir the ac prediction direction
  56  */
  57 void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
  58 {
  59     int i;
  60     int16_t *ac_val, *ac_val1;
  61     int8_t *const qscale_table = s->current_picture.qscale_table;
  62
  63     /* find prediction */
  64     ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
  65     ac_val1 = ac_val;
  66     if (s->ac_pred) {
  67         if (dir == 0) {
  68             const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride;
  69             /* left prediction */
  70             ac_val -= 16;
  71
  72             if (s->mb_x == 0 || s->qscale == qscale_table[xy] ||
  73                 n == 1 || n == 3) {
  74                 /* same qscale */
  75                 for (i = 1; i < 8; i++)
  76                     block[s->dsp.idct_permutation[i << 3]] += ac_val[i];
  77             } else {
  78                 /* different qscale, we must rescale */
  79                 for (i = 1; i < 8; i++)
  80                     block[s->dsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
  81             }
  82         } else {
  83             const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
  84             /* top prediction */
  85             ac_val -= 16 * s->block_wrap[n];
  86
  87             if (s->mb_y == 0 || s->qscale == qscale_table[xy] ||
  88                 n == 2 || n == 3) {
  89                 /* same qscale */
  90                 for (i = 1; i < 8; i++)
  91                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
  92             } else {
  93                 /* different qscale, we must rescale */
  94                 for (i = 1; i < 8; i++)
  95                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
  96             }
  97         }
  98     }
  99     /* left copy */
 100     for (i = 1; i < 8; i++)
 101         ac_val1[i] = block[s->dsp.idct_permutation[i << 3]];
 102
 103     /* top copy */
 104     for (i = 1; i < 8; i++)
 105         ac_val1[8 + i] = block[s->dsp.idct_permutation[i]];
 106 }
 107
 108 /**
 109  * check if the next stuff is a resync marker or the end.
 110  * @return 0 if not
 111  */
 112 static inline int mpeg4_is_resync(MpegEncContext *s)
 113 {
 114     int bits_count = get_bits_count(&s->gb);
 115     int v          = show_bits(&s->gb, 16);
 116
 117     if (s->workaround_bugs & FF_BUG_NO_PADDING && !s->resync_marker)
 118         return 0;
 119
 120     while (v <= 0xFF) {
 121         if (s->pict_type == AV_PICTURE_TYPE_B ||
 122             (v >> (8 - s->pict_type) != 1) || s->partitioned_frame)
 123             break;
 124         skip_bits(&s->gb, 8 + s->pict_type);
 125         bits_count += 8 + s->pict_type;
 126         v = show_bits(&s->gb, 16);
 127     }
 128
 129     if (bits_count + 8 >= s->gb.size_in_bits) {
 130         v >>= 8;
 131         v  |= 0x7F >> (7 - (bits_count & 7));
 132
 133         if (v == 0x7F)
 134             return s->mb_num;
 135     } else {
 136         if (v == ff_mpeg4_resync_prefix[bits_count & 7]) {
 137             int len, mb_num;
 138             int mb_num_bits = av_log2(s->mb_num - 1) + 1;
 139             GetBitContext gb = s->gb;
 140
 141             skip_bits(&s->gb, 1);
 142             align_get_bits(&s->gb);
 143
 144             for (len = 0; len < 32; len++)
 145                 if (get_bits1(&s->gb))
 146                     break;
 147
 148             mb_num = get_bits(&s->gb, mb_num_bits);
 149             if (!mb_num || mb_num > s->mb_num || get_bits_count(&s->gb)+6 > s->gb.size_in_bits)
 150                 mb_num= -1;
 151
 152             s->gb = gb;
 153
 154             if (len >= ff_mpeg4_get_video_packet_prefix_length(s))
 155                 return mb_num;
 156         }
 157     }
 158     return 0;
 159 }
 160
 161 static int mpeg4_decode_sprite_trajectory(MpegEncContext *s, GetBitContext *gb)
 162 {
 163     int a     = 2 << s->sprite_warping_accuracy;
 164     int rho   = 3  - s->sprite_warping_accuracy;
 165     int r     = 16 / a;
 166     int alpha = 0;
 167     int beta  = 0;
 168     int w     = s->width;
 169     int h     = s->height;
 170     int min_ab, i, w2, h2, w3, h3;
 171     int sprite_ref[4][2];
 172     int virtual_ref[2][2];
 173
 174     // only true for rectangle shapes
 175     const int vop_ref[4][2] = { { 0, 0 },         { s->width, 0 },
 176                                 { 0, s->height }, { s->width, s->height } };
 177     int d[4][2]             = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
 178
 179     if (w <= 0 || h <= 0)
 180         return AVERROR_INVALIDDATA;
 181
 182     for (i = 0; i < s->num_sprite_warping_points; i++) {
 183         int length;
 184         int x = 0, y = 0;
 185
 186         length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
 187         if (length)
 188             x = get_xbits(gb, length);
 189
 190         if (!(s->divx_version == 500 && s->divx_build == 413))
 191             skip_bits1(gb);     /* marker bit */
 192
 193         length = get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
 194         if (length)
 195             y = get_xbits(gb, length);
 196
 197         skip_bits1(gb);         /* marker bit */
 198         s->sprite_traj[i][0] = d[i][0] = x;
 199         s->sprite_traj[i][1] = d[i][1] = y;
 200     }
 201     for (; i < 4; i++)
 202         s->sprite_traj[i][0] = s->sprite_traj[i][1] = 0;
 203
 204     while ((1 << alpha) < w)
 205         alpha++;
 206     while ((1 << beta) < h)
 207         beta++;  /* typo in the mpeg4 std for the definition of w' and h' */
 208     w2 = 1 << alpha;
 209     h2 = 1 << beta;
 210
 211     // Note, the 4th point isn't used for GMC
 212     if (s->divx_version == 500 && s->divx_build == 413) {
 213         sprite_ref[0][0] = a * vop_ref[0][0] + d[0][0];
 214         sprite_ref[0][1] = a * vop_ref[0][1] + d[0][1];
 215         sprite_ref[1][0] = a * vop_ref[1][0] + d[0][0] + d[1][0];
 216         sprite_ref[1][1] = a * vop_ref[1][1] + d[0][1] + d[1][1];
 217         sprite_ref[2][0] = a * vop_ref[2][0] + d[0][0] + d[2][0];
 218         sprite_ref[2][1] = a * vop_ref[2][1] + d[0][1] + d[2][1];
 219     } else {
 220         sprite_ref[0][0] = (a >> 1) * (2 * vop_ref[0][0] + d[0][0]);
 221         sprite_ref[0][1] = (a >> 1) * (2 * vop_ref[0][1] + d[0][1]);
 222         sprite_ref[1][0] = (a >> 1) * (2 * vop_ref[1][0] + d[0][0] + d[1][0]);
 223         sprite_ref[1][1] = (a >> 1) * (2 * vop_ref[1][1] + d[0][1] + d[1][1]);
 224         sprite_ref[2][0] = (a >> 1) * (2 * vop_ref[2][0] + d[0][0] + d[2][0]);
 225         sprite_ref[2][1] = (a >> 1) * (2 * vop_ref[2][1] + d[0][1] + d[2][1]);
 226     }
 227     /* sprite_ref[3][0] = (a >> 1) * (2 * vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
 228      * sprite_ref[3][1] = (a >> 1) * (2 * vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
 229
 230     /* this is mostly identical to the mpeg4 std (and is totally unreadable
 231      * because of that...). Perhaps it should be reordered to be more readable.
 232      * The idea behind this virtual_ref mess is to be able to use shifts later
 233      * per pixel instead of divides so the distance between points is converted
 234      * from w&h based to w2&h2 based which are of the 2^x form. */
 235     virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +
 236                          ROUNDED_DIV(((w - w2) *
 237                                       (r * sprite_ref[0][0] - 16 * vop_ref[0][0]) +
 238                                       w2 * (r * sprite_ref[1][0] - 16 * vop_ref[1][0])), w);
 239     virtual_ref[0][1] = 16 * vop_ref[0][1] +
 240                         ROUNDED_DIV(((w - w2) *
 241                                      (r * sprite_ref[0][1] - 16 * vop_ref[0][1]) +
 242                                      w2 * (r * sprite_ref[1][1] - 16 * vop_ref[1][1])), w);
 243     virtual_ref[1][0] = 16 * vop_ref[0][0] +
 244                         ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16 * vop_ref[0][0]) +
 245                                      h2 * (r * sprite_ref[2][0] - 16 * vop_ref[2][0])), h);
 246     virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +
 247                         ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16 * vop_ref[0][1]) +
 248                                      h2 * (r * sprite_ref[2][1] - 16 * vop_ref[2][1])), h);
 249
 250     switch (s->num_sprite_warping_points) {
 251     case 0:
 252         s->sprite_offset[0][0] =
 253         s->sprite_offset[0][1] =
 254         s->sprite_offset[1][0] =
 255         s->sprite_offset[1][1] = 0;
 256         s->sprite_delta[0][0]  = a;
 257         s->sprite_delta[0][1]  =
 258         s->sprite_delta[1][0]  = 0;
 259         s->sprite_delta[1][1]  = a;
 260         s->sprite_shift[0]     =
 261         s->sprite_shift[1]     = 0;
 262         break;
 263     case 1:     // GMC only
 264         s->sprite_offset[0][0] = sprite_ref[0][0] - a * vop_ref[0][0];
 265         s->sprite_offset[0][1] = sprite_ref[0][1] - a * vop_ref[0][1];
 266         s->sprite_offset[1][0] = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
 267                                  a * (vop_ref[0][0] / 2);
 268         s->sprite_offset[1][1] = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
 269                                  a * (vop_ref[0][1] / 2);
 270         s->sprite_delta[0][0]  = a;
 271         s->sprite_delta[0][1]  =
 272         s->sprite_delta[1][0]  = 0;
 273         s->sprite_delta[1][1]  = a;
 274         s->sprite_shift[0]     =
 275         s->sprite_shift[1]     = 0;
 276         break;
 277     case 2:
 278         s->sprite_offset[0][0] = (sprite_ref[0][0] << (alpha + rho)) +
 279                                  (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 280                                  (-vop_ref[0][0]) +
 281                                  (r * sprite_ref[0][1] - virtual_ref[0][1]) *
 282                                  (-vop_ref[0][1]) + (1 << (alpha + rho - 1));
 283         s->sprite_offset[0][1] = (sprite_ref[0][1] << (alpha + rho)) +
 284                                  (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
 285                                  (-vop_ref[0][0]) +
 286                                  (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 287                                  (-vop_ref[0][1]) + (1 << (alpha + rho - 1));
 288         s->sprite_offset[1][0] = ((-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 289                                   (-2 * vop_ref[0][0] + 1) +
 290                                   (r * sprite_ref[0][1] - virtual_ref[0][1]) *
 291                                   (-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
 292                                   sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));
 293         s->sprite_offset[1][1] = ((-r * sprite_ref[0][1] + virtual_ref[0][1]) *
 294                                   (-2 * vop_ref[0][0] + 1) +
 295                                   (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 296                                   (-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
 297                                   sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));
 298         s->sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
 299         s->sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);
 300         s->sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);
 301         s->sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
 302
 303         s->sprite_shift[0] = alpha + rho;
 304         s->sprite_shift[1] = alpha + rho + 2;
 305         break;
 306     case 3:
 307         min_ab = FFMIN(alpha, beta);
 308         w3     = w2 >> min_ab;
 309         h3     = h2 >> min_ab;
 310         s->sprite_offset[0][0] = (sprite_ref[0][0] << (alpha + beta + rho - min_ab)) +
 311                                  (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 312                                  h3 * (-vop_ref[0][0]) +
 313                                  (-r * sprite_ref[0][0] + virtual_ref[1][0]) *
 314                                  w3 * (-vop_ref[0][1]) +
 315                                  (1 << (alpha + beta + rho - min_ab - 1));
 316         s->sprite_offset[0][1] = (sprite_ref[0][1] << (alpha + beta + rho - min_ab)) +
 317                                  (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
 318                                  h3 * (-vop_ref[0][0]) +
 319                                  (-r * sprite_ref[0][1] + virtual_ref[1][1]) *
 320                                  w3 * (-vop_ref[0][1]) +
 321                                  (1 << (alpha + beta + rho - min_ab - 1));
 322         s->sprite_offset[1][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
 323                                  h3 * (-2 * vop_ref[0][0] + 1) +
 324                                  (-r * sprite_ref[0][0] + virtual_ref[1][0]) *
 325                                  w3 * (-2 * vop_ref[0][1] + 1) + 2 * w2 * h3 *
 326                                  r * sprite_ref[0][0] - 16 * w2 * h3 +
 327                                  (1 << (alpha + beta + rho - min_ab + 1));
 328         s->sprite_offset[1][1] = (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
 329                                  h3 * (-2 * vop_ref[0][0] + 1) +
 330                                  (-r * sprite_ref[0][1] + virtual_ref[1][1]) *
 331                                  w3 * (-2 * vop_ref[0][1] + 1) + 2 * w2 * h3 *
 332                                  r * sprite_ref[0][1] - 16 * w2 * h3 +
 333                                  (1 << (alpha + beta + rho - min_ab + 1));
 334         s->sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3;
 335         s->sprite_delta[0][1] = (-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3;
 336         s->sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3;
 337         s->sprite_delta[1][1] = (-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3;
 338
 339         s->sprite_shift[0] = alpha + beta + rho - min_ab;
 340         s->sprite_shift[1] = alpha + beta + rho - min_ab + 2;
 341         break;
 342     }
 343     /* try to simplify the situation */
 344     if (s->sprite_delta[0][0] == a << s->sprite_shift[0] &&
 345         s->sprite_delta[0][1] == 0 &&
 346         s->sprite_delta[1][0] == 0 &&
 347         s->sprite_delta[1][1] == a << s->sprite_shift[0]) {
 348         s->sprite_offset[0][0] >>= s->sprite_shift[0];
 349         s->sprite_offset[0][1] >>= s->sprite_shift[0];
 350         s->sprite_offset[1][0] >>= s->sprite_shift[1];
 351         s->sprite_offset[1][1] >>= s->sprite_shift[1];
 352         s->sprite_delta[0][0] = a;
 353         s->sprite_delta[0][1] = 0;
 354         s->sprite_delta[1][0] = 0;
 355         s->sprite_delta[1][1] = a;
 356         s->sprite_shift[0] = 0;
 357         s->sprite_shift[1] = 0;
 358         s->real_sprite_warping_points = 1;
 359     } else {
 360         int shift_y = 16 - s->sprite_shift[0];
 361         int shift_c = 16 - s->sprite_shift[1];
 362         for (i = 0; i < 2; i++) {
 363             s->sprite_offset[0][i] <<= shift_y;
 364             s->sprite_offset[1][i] <<= shift_c;
 365             s->sprite_delta[0][i]  <<= shift_y;
 366             s->sprite_delta[1][i]  <<= shift_y;
 367             s->sprite_shift[i]       = 16;
 368         }
 369         s->real_sprite_warping_points = s->num_sprite_warping_points;
 370     }
 371
 372     return 0;
 373 }
 374
 375 static int decode_new_pred(MpegEncContext *s, GetBitContext *gb) {
 376     int len = FFMIN(s->time_increment_bits + 3, 15);
 377
 378     get_bits(gb, len);
 379     if (get_bits1(gb))
 380         get_bits(gb, len);
 381     check_marker(gb, "after new_pred");
 382
 383     return 0;
 384 }
 385
 386 /**
 387  * Decode the next video packet.
 388  * @return <0 if something went wrong
 389  */
 390 int ff_mpeg4_decode_video_packet_header(MpegEncContext *s)
 391 {
 392     int mb_num_bits      = av_log2(s->mb_num - 1) + 1;
 393     int header_extension = 0, mb_num, len;
 394
 395     /* is there enough space left for a video packet + header */
 396     if (get_bits_count(&s->gb) > s->gb.size_in_bits - 20)
 397         return -1;
 398
 399     for (len = 0; len < 32; len++)
 400         if (get_bits1(&s->gb))
 401             break;
 402
 403     if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
 404         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
 405         return -1;
 406     }
 407
 408     if (s->shape != RECT_SHAPE) {
 409         header_extension = get_bits1(&s->gb);
 410         // FIXME more stuff here
 411     }
 412
 413     mb_num = get_bits(&s->gb, mb_num_bits);
 414     if (mb_num >= s->mb_num) {
 415         av_log(s->avctx, AV_LOG_ERROR,
 416                "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
 417         return -1;
 418     }
 419
 420     s->mb_x = mb_num % s->mb_width;
 421     s->mb_y = mb_num / s->mb_width;
 422
 423     if (s->shape != BIN_ONLY_SHAPE) {
 424         int qscale = get_bits(&s->gb, s->quant_precision);
 425         if (qscale)
 426             s->chroma_qscale = s->qscale = qscale;
 427     }
 428
 429     if (s->shape == RECT_SHAPE)
 430         header_extension = get_bits1(&s->gb);
 431
 432     if (header_extension) {
 433         int time_incr = 0;
 434
 435         while (get_bits1(&s->gb) != 0)
 436             time_incr++;
 437
 438         check_marker(&s->gb, "before time_increment in video packed header");
 439         skip_bits(&s->gb, s->time_increment_bits);      /* time_increment */
 440         check_marker(&s->gb, "before vop_coding_type in video packed header");
 441
 442         skip_bits(&s->gb, 2); /* vop coding type */
 443         // FIXME not rect stuff here
 444
 445         if (s->shape != BIN_ONLY_SHAPE) {
 446             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
 447             // FIXME don't just ignore everything
 448             if (s->pict_type == AV_PICTURE_TYPE_S &&
 449                 s->vol_sprite_usage == GMC_SPRITE) {
 450                 if (mpeg4_decode_sprite_trajectory(s, &s->gb) < 0)
 451                     return AVERROR_INVALIDDATA;
 452                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
 453             }
 454
 455             // FIXME reduced res stuff here
 456
 457             if (s->pict_type != AV_PICTURE_TYPE_I) {
 458                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
 459                 if (f_code == 0)
 460                     av_log(s->avctx, AV_LOG_ERROR,
 461                            "Error, video packet header damaged (f_code=0)\n");
 462             }
 463             if (s->pict_type == AV_PICTURE_TYPE_B) {
 464                 int b_code = get_bits(&s->gb, 3);
 465                 if (b_code == 0)
 466                     av_log(s->avctx, AV_LOG_ERROR,
 467                            "Error, video packet header damaged (b_code=0)\n");
 468             }
 469         }
 470     }
 471     if (s->new_pred)
 472         decode_new_pred(s, &s->gb);
 473
 474     return 0;
 475 }
 476
 477 /**
 478  * Get the average motion vector for a GMC MB.
 479  * @param n either 0 for the x component or 1 for y
 480  * @return the average MV for a GMC MB
 481  */
 482 static inline int get_amv(MpegEncContext *s, int n)
 483 {
 484     int x, y, mb_v, sum, dx, dy, shift;
 485     int len     = 1 << (s->f_code + 4);
 486     const int a = s->sprite_warping_accuracy;
 487
 488     if (s->workaround_bugs & FF_BUG_AMV)
 489         len >>= s->quarter_sample;
 490
 491     if (s->real_sprite_warping_points == 1) {
 492         if (s->divx_version == 500 && s->divx_build == 413)
 493             sum = s->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
 494         else
 495             sum = RSHIFT(s->sprite_offset[0][n] << s->quarter_sample, a);
 496     } else {
 497         dx    = s->sprite_delta[n][0];
 498         dy    = s->sprite_delta[n][1];
 499         shift = s->sprite_shift[0];
 500         if (n)
 501             dy -= 1 << (shift + a + 1);
 502         else
 503             dx -= 1 << (shift + a + 1);
 504         mb_v = s->sprite_offset[0][n] + dx * s->mb_x * 16 + dy * s->mb_y * 16;
 505
 506         sum = 0;
 507         for (y = 0; y < 16; y++) {
 508             int v;
 509
 510             v = mb_v + dy * y;
 511             // FIXME optimize
 512             for (x = 0; x < 16; x++) {
 513                 sum += v >> shift;
 514                 v   += dx;
 515             }
 516         }
 517         sum = RSHIFT(sum, a + 8 - s->quarter_sample);
 518     }
 519
 520     if (sum < -len)
 521         sum = -len;
 522     else if (sum >= len)
 523         sum = len - 1;
 524
 525     return sum;
 526 }
 527
 528 /**
 529  * Decode the dc value.
 530  * @param n block index (0-3 are luma, 4-5 are chroma)
 531  * @param dir_ptr the prediction direction will be stored here
 532  * @return the quantized dc
 533  */
 534 static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
 535 {
 536     int level, code;
 537
 538     if (n < 4)
 539         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
 540     else
 541         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
 542
 543     if (code < 0 || code > 9 /* && s->nbit < 9 */) {
 544         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 545         return -1;
 546     }
 547
 548     if (code == 0) {
 549         level = 0;
 550     } else {
 551         if (IS_3IV1) {
 552             if (code == 1)
 553                 level = 2 * get_bits1(&s->gb) - 1;
 554             else {
 555                 if (get_bits1(&s->gb))
 556                     level = get_bits(&s->gb, code - 1) + (1 << (code - 1));
 557                 else
 558                     level = -get_bits(&s->gb, code - 1) - (1 << (code - 1));
 559             }
 560         } else {
 561             level = get_xbits(&s->gb, code);
 562         }
 563
 564         if (code > 8) {
 565             if (get_bits1(&s->gb) == 0) { /* marker */
 566                 if (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
 567                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
 568                     return -1;
 569                 }
 570             }
 571         }
 572     }
 573
 574     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
 575 }
 576
 577 /**
 578  * Decode first partition.
 579  * @return number of MBs decoded or <0 if an error occurred
 580  */
 581 static int mpeg4_decode_partition_a(MpegEncContext *s)
 582 {
 583     int mb_num = 0;
 584     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 585
 586     /* decode first partition */
 587     s->first_slice_line = 1;
 588     for (; s->mb_y < s->mb_height; s->mb_y++) {
 589         ff_init_block_index(s);
 590         for (; s->mb_x < s->mb_width; s->mb_x++) {
 591             const int xy = s->mb_x + s->mb_y * s->mb_stride;
 592             int cbpc;
 593             int dir = 0;
 594
 595             mb_num++;
 596             ff_update_block_index(s);
 597             if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
 598                 s->first_slice_line = 0;
 599
 600             if (s->pict_type == AV_PICTURE_TYPE_I) {
 601                 int i;
 602
 603                 do {
 604                     if (show_bits_long(&s->gb, 19) == DC_MARKER)
 605                         return mb_num - 1;
 606
 607                     cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
 608                     if (cbpc < 0) {
 609                         av_log(s->avctx, AV_LOG_ERROR,
 610                                "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
 611                         return -1;
 612                     }
 613                 } while (cbpc == 8);
 614
 615                 s->cbp_table[xy]               = cbpc & 3;
 616                 s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
 617                 s->mb_intra                    = 1;
 618
 619                 if (cbpc & 4)
 620                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 621
 622                 s->current_picture.qscale_table[xy] = s->qscale;
 623
 624                 s->mbintra_table[xy] = 1;
 625                 for (i = 0; i < 6; i++) {
 626                     int dc_pred_dir;
 627                     int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
 628                     if (dc < 0) {
 629                         av_log(s->avctx, AV_LOG_ERROR,
 630                                "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
 631                         return -1;
 632                     }
 633                     dir <<= 1;
 634                     if (dc_pred_dir)
 635                         dir |= 1;
 636                 }
 637                 s->pred_dir_table[xy] = dir;
 638             } else { /* P/S_TYPE */
 639                 int mx, my, pred_x, pred_y, bits;
 640                 int16_t *const mot_val = s->current_picture.motion_val[0][s->block_index[0]];
 641                 const int stride       = s->b8_stride * 2;
 642
 643 try_again:
 644                 bits = show_bits(&s->gb, 17);
 645                 if (bits == MOTION_MARKER)
 646                     return mb_num - 1;
 647
 648                 skip_bits1(&s->gb);
 649                 if (bits & 0x10000) {
 650                     /* skip mb */
 651                     if (s->pict_type == AV_PICTURE_TYPE_S &&
 652                         s->vol_sprite_usage == GMC_SPRITE) {
 653                         s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
 654                                                          MB_TYPE_16x16 |
 655                                                          MB_TYPE_GMC   |
 656                                                          MB_TYPE_L0;
 657                         mx = get_amv(s, 0);
 658                         my = get_amv(s, 1);
 659                     } else {
 660                         s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
 661                                                          MB_TYPE_16x16 |
 662                                                          MB_TYPE_L0;
 663                         mx = my = 0;
 664                     }
 665                     mot_val[0]          =
 666                     mot_val[2]          =
 667                     mot_val[0 + stride] =
 668                     mot_val[2 + stride] = mx;
 669                     mot_val[1]          =
 670                     mot_val[3]          =
 671                     mot_val[1 + stride] =
 672                     mot_val[3 + stride] = my;
 673
 674                     if (s->mbintra_table[xy])
 675                         ff_clean_intra_table_entries(s);
 676                     continue;
 677                 }
 678
 679                 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 680                 if (cbpc < 0) {
 681                     av_log(s->avctx, AV_LOG_ERROR,
 682                            "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
 683                     return -1;
 684                 }
 685                 if (cbpc == 20)
 686                     goto try_again;
 687
 688                 s->cbp_table[xy] = cbpc & (8 + 3);  // 8 is dquant
 689
 690                 s->mb_intra = ((cbpc & 4) != 0);
 691
 692                 if (s->mb_intra) {
 693                     s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
 694                     s->mbintra_table[xy] = 1;
 695                     mot_val[0]          =
 696                     mot_val[2]          =
 697                     mot_val[0 + stride] =
 698                     mot_val[2 + stride] = 0;
 699                     mot_val[1]          =
 700                     mot_val[3]          =
 701                     mot_val[1 + stride] =
 702                     mot_val[3 + stride] = 0;
 703                 } else {
 704                     if (s->mbintra_table[xy])
 705                         ff_clean_intra_table_entries(s);
 706
 707                     if (s->pict_type == AV_PICTURE_TYPE_S &&
 708                         s->vol_sprite_usage == GMC_SPRITE &&
 709                         (cbpc & 16) == 0)
 710                         s->mcsel = get_bits1(&s->gb);
 711                     else
 712                         s->mcsel = 0;
 713
 714                     if ((cbpc & 16) == 0) {
 715                         /* 16x16 motion prediction */
 716
 717                         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 718                         if (!s->mcsel) {
 719                             mx = ff_h263_decode_motion(s, pred_x, s->f_code);
 720                             if (mx >= 0xffff)
 721                                 return -1;
 722
 723                             my = ff_h263_decode_motion(s, pred_y, s->f_code);
 724                             if (my >= 0xffff)
 725                                 return -1;
 726                             s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
 727                                                              MB_TYPE_L0;
 728                         } else {
 729                             mx = get_amv(s, 0);
 730                             my = get_amv(s, 1);
 731                             s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
 732                                                              MB_TYPE_GMC   |
 733                                                              MB_TYPE_L0;
 734                         }
 735
 736                         mot_val[0]          =
 737                         mot_val[2]          =
 738                         mot_val[0 + stride] =
 739                         mot_val[2 + stride] = mx;
 740                         mot_val[1]          =
 741                         mot_val[3]          =
 742                         mot_val[1 + stride] =
 743                         mot_val[3 + stride] = my;
 744                     } else {
 745                         int i;
 746                         s->current_picture.mb_type[xy] = MB_TYPE_8x8 |
 747                                                          MB_TYPE_L0;
 748                         for (i = 0; i < 4; i++) {
 749                             int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 750                             mx = ff_h263_decode_motion(s, pred_x, s->f_code);
 751                             if (mx >= 0xffff)
 752                                 return -1;
 753
 754                             my = ff_h263_decode_motion(s, pred_y, s->f_code);
 755                             if (my >= 0xffff)
 756                                 return -1;
 757                             mot_val[0] = mx;
 758                             mot_val[1] = my;
 759                         }
 760                     }
 761                 }
 762             }
 763         }
 764         s->mb_x = 0;
 765     }
 766
 767     return mb_num;
 768 }
 769
 770 /**
 771  * decode second partition.
 772  * @return <0 if an error occurred
 773  */
 774 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
 775 {
 776     int mb_num = 0;
 777     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 778
 779     s->mb_x = s->resync_mb_x;
 780     s->first_slice_line = 1;
 781     for (s->mb_y = s->resync_mb_y; mb_num < mb_count; s->mb_y++) {
 782         ff_init_block_index(s);
 783         for (; mb_num < mb_count && s->mb_x < s->mb_width; s->mb_x++) {
 784             const int xy = s->mb_x + s->mb_y * s->mb_stride;
 785
 786             mb_num++;
 787             ff_update_block_index(s);
 788             if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
 789                 s->first_slice_line = 0;
 790
 791             if (s->pict_type == AV_PICTURE_TYPE_I) {
 792                 int ac_pred = get_bits1(&s->gb);
 793                 int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 794                 if (cbpy < 0) {
 795                     av_log(s->avctx, AV_LOG_ERROR,
 796                            "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 797                     return -1;
 798                 }
 799
 800                 s->cbp_table[xy]               |= cbpy << 2;
 801                 s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
 802             } else { /* P || S_TYPE */
 803                 if (IS_INTRA(s->current_picture.mb_type[xy])) {
 804                     int i;
 805                     int dir     = 0;
 806                     int ac_pred = get_bits1(&s->gb);
 807                     int cbpy    = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 808
 809                     if (cbpy < 0) {
 810                         av_log(s->avctx, AV_LOG_ERROR,
 811                                "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 812                         return -1;
 813                     }
 814
 815                     if (s->cbp_table[xy] & 8)
 816                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 817                     s->current_picture.qscale_table[xy] = s->qscale;
 818
 819                     for (i = 0; i < 6; i++) {
 820                         int dc_pred_dir;
 821                         int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
 822                         if (dc < 0) {
 823                             av_log(s->avctx, AV_LOG_ERROR,
 824                                    "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
 825                             return -1;
 826                         }
 827                         dir <<= 1;
 828                         if (dc_pred_dir)
 829                             dir |= 1;
 830                     }
 831                     s->cbp_table[xy]               &= 3;  // remove dquant
 832                     s->cbp_table[xy]               |= cbpy << 2;
 833                     s->current_picture.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
 834                     s->pred_dir_table[xy]           = dir;
 835                 } else if (IS_SKIP(s->current_picture.mb_type[xy])) {
 836                     s->current_picture.qscale_table[xy] = s->qscale;
 837                     s->cbp_table[xy]                    = 0;
 838                 } else {
 839                     int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 840
 841                     if (cbpy < 0) {
 842                         av_log(s->avctx, AV_LOG_ERROR,
 843                                "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 844                         return -1;
 845                     }
 846
 847                     if (s->cbp_table[xy] & 8)
 848                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 849                     s->current_picture.qscale_table[xy] = s->qscale;
 850
 851                     s->cbp_table[xy] &= 3;  // remove dquant
 852                     s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
 853                 }
 854             }
 855         }
 856         if (mb_num >= mb_count)
 857             return 0;
 858         s->mb_x = 0;
 859     }
 860     return 0;
 861 }
 862
 863 /**
 864  * Decode the first and second partition.
 865  * @return <0 if error (and sets error type in the error_status_table)
 866  */
 867 int ff_mpeg4_decode_partitions(MpegEncContext *s)
 868 {
 869     int mb_num;
 870     const int part_a_error = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR;
 871     const int part_a_end   = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_END   | ER_MV_END)   : ER_MV_END;
 872
 873     mb_num = mpeg4_decode_partition_a(s);
 874     if (mb_num < 0) {
 875         ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 876                         s->mb_x, s->mb_y, part_a_error);
 877         return -1;
 878     }
 879
 880     if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) {
 881         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
 882         ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 883                         s->mb_x, s->mb_y, part_a_error);
 884         return -1;
 885     }
 886
 887     s->mb_num_left = mb_num;
 888
 889     if (s->pict_type == AV_PICTURE_TYPE_I) {
 890         while (show_bits(&s->gb, 9) == 1)
 891             skip_bits(&s->gb, 9);
 892         if (get_bits_long(&s->gb, 19) != DC_MARKER) {
 893             av_log(s->avctx, AV_LOG_ERROR,
 894                    "marker missing after first I partition at %d %d\n",
 895                    s->mb_x, s->mb_y);
 896             return -1;
 897         }
 898     } else {
 899         while (show_bits(&s->gb, 10) == 1)
 900             skip_bits(&s->gb, 10);
 901         if (get_bits(&s->gb, 17) != MOTION_MARKER) {
 902             av_log(s->avctx, AV_LOG_ERROR,
 903                    "marker missing after first P partition at %d %d\n",
 904                    s->mb_x, s->mb_y);
 905             return -1;
 906         }
 907     }
 908     ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 909                     s->mb_x - 1, s->mb_y, part_a_end);
 910
 911     if (mpeg4_decode_partition_b(s, mb_num) < 0) {
 912         if (s->pict_type == AV_PICTURE_TYPE_P)
 913             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 914                             s->mb_x, s->mb_y, ER_DC_ERROR);
 915         return -1;
 916     } else {
 917         if (s->pict_type == AV_PICTURE_TYPE_P)
 918             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
 919                             s->mb_x - 1, s->mb_y, ER_DC_END);
 920     }
 921
 922     return 0;
 923 }
 924
 925 /**
 926  * Decode a block.
 927  * @return <0 if an error occurred
 928  */
 929 static inline int mpeg4_decode_block(MpegEncContext *s, int16_t *block,
 930                                      int n, int coded, int intra, int rvlc)
 931 {
 932     int level, i, last, run, qmul, qadd;
 933     int av_uninit(dc_pred_dir);
 934     RLTable *rl;
 935     RL_VLC_ELEM *rl_vlc;
 936     const uint8_t *scan_table;
 937
 938     // Note intra & rvlc should be optimized away if this is inlined
 939
 940     if (intra) {
 941         if (s->use_intra_dc_vlc) {
 942             /* DC coef */
 943             if (s->partitioned_frame) {
 944                 level = s->dc_val[0][s->block_index[n]];
 945                 if (n < 4)
 946                     level = FASTDIV((level + (s->y_dc_scale >> 1)), s->y_dc_scale);
 947                 else
 948                     level = FASTDIV((level + (s->c_dc_scale >> 1)), s->c_dc_scale);
 949                 dc_pred_dir = (s->pred_dir_table[s->mb_x + s->mb_y * s->mb_stride] << n) & 32;
 950             } else {
 951                 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
 952                 if (level < 0)
 953                     return -1;
 954             }
 955             block[0] = level;
 956             i        = 0;
 957         } else {
 958             i = -1;
 959             ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
 960         }
 961         if (!coded)
 962             goto not_coded;
 963
 964         if (rvlc) {
 965             rl     = &ff_rvlc_rl_intra;
 966             rl_vlc = ff_rvlc_rl_intra.rl_vlc[0];
 967         } else {
 968             rl     = &ff_mpeg4_rl_intra;
 969             rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
 970         }
 971         if (s->ac_pred) {
 972             if (dc_pred_dir == 0)
 973                 scan_table = s->intra_v_scantable.permutated;  /* left */
 974             else
 975                 scan_table = s->intra_h_scantable.permutated;  /* top */
 976         } else {
 977             scan_table = s->intra_scantable.permutated;
 978         }
 979         qmul = 1;
 980         qadd = 0;
 981     } else {
 982         i = -1;
 983         if (!coded) {
 984             s->block_last_index[n] = i;
 985             return 0;
 986         }
 987         if (rvlc)
 988             rl = &ff_rvlc_rl_inter;
 989         else
 990             rl = &ff_h263_rl_inter;
 991
 992         scan_table = s->intra_scantable.permutated;
 993
 994         if (s->mpeg_quant) {
 995             qmul = 1;
 996             qadd = 0;
 997             if (rvlc)
 998                 rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
 999             else
1000                 rl_vlc = ff_h263_rl_inter.rl_vlc[0];
1001         } else {
1002             qmul = s->qscale << 1;
1003             qadd = (s->qscale - 1) | 1;
1004             if (rvlc)
1005                 rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
1006             else
1007                 rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
1008         }
1009     }
1010     {
1011         OPEN_READER(re, &s->gb);
1012         for (;;) {
1013             UPDATE_CACHE(re, &s->gb);
1014             GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1015             if (level == 0) {
1016                 /* escape */
1017                 if (rvlc) {
1018                     if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1019                         av_log(s->avctx, AV_LOG_ERROR,
1020                                "1. marker bit missing in rvlc esc\n");
1021                         return -1;
1022                     }
1023                     SKIP_CACHE(re, &s->gb, 1);
1024
1025                     last = SHOW_UBITS(re, &s->gb, 1);
1026                     SKIP_CACHE(re, &s->gb, 1);
1027                     run = SHOW_UBITS(re, &s->gb, 6);
1028                     SKIP_COUNTER(re, &s->gb, 1 + 1 + 6);
1029                     UPDATE_CACHE(re, &s->gb);
1030
1031                     if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1032                         av_log(s->avctx, AV_LOG_ERROR,
1033                                "2. marker bit missing in rvlc esc\n");
1034                         return -1;
1035                     }
1036                     SKIP_CACHE(re, &s->gb, 1);
1037
1038                     level = SHOW_UBITS(re, &s->gb, 11);
1039                     SKIP_CACHE(re, &s->gb, 11);
1040
1041                     if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
1042                         av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
1043                         return -1;
1044                     }
1045                     SKIP_CACHE(re, &s->gb, 5);
1046
1047                     level = level * qmul + qadd;
1048                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1049                     SKIP_COUNTER(re, &s->gb, 1 + 11 + 5 + 1);
1050
1051                     i += run + 1;
1052                     if (last)
1053                         i += 192;
1054                 } else {
1055                     int cache;
1056                     cache = GET_CACHE(re, &s->gb);
1057
1058                     if (IS_3IV1)
1059                         cache ^= 0xC0000000;
1060
1061                     if (cache & 0x80000000) {
1062                         if (cache & 0x40000000) {
1063                             /* third escape */
1064                             SKIP_CACHE(re, &s->gb, 2);
1065                             last = SHOW_UBITS(re, &s->gb, 1);
1066                             SKIP_CACHE(re, &s->gb, 1);
1067                             run = SHOW_UBITS(re, &s->gb, 6);
1068                             SKIP_COUNTER(re, &s->gb, 2 + 1 + 6);
1069                             UPDATE_CACHE(re, &s->gb);
1070
1071                             if (IS_3IV1) {
1072                                 level = SHOW_SBITS(re, &s->gb, 12);
1073                                 LAST_SKIP_BITS(re, &s->gb, 12);
1074                             } else {
1075                                 if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1076                                     av_log(s->avctx, AV_LOG_ERROR,
1077                                            "1. marker bit missing in 3. esc\n");
1078                                     return -1;
1079                                 }
1080                                 SKIP_CACHE(re, &s->gb, 1);
1081
1082                                 level = SHOW_SBITS(re, &s->gb, 12);
1083                                 SKIP_CACHE(re, &s->gb, 12);
1084
1085                                 if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1086                                     av_log(s->avctx, AV_LOG_ERROR,
1087                                            "2. marker bit missing in 3. esc\n");
1088                                     return -1;
1089                                 }
1090
1091                                 SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
1092                             }
1093
1094 #if 0
1095                             if (s->error_recognition >= FF_ER_COMPLIANT) {
1096                                 const int abs_level= FFABS(level);
1097                                 if (abs_level<=MAX_LEVEL && run<=MAX_RUN) {
1098                                     const int run1= run - rl->max_run[last][abs_level] - 1;
1099                                     if (abs_level <= rl->max_level[last][run]) {
1100                                         av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1101                                         return -1;
1102                                     }
1103                                     if (s->error_recognition > FF_ER_COMPLIANT) {
1104                                         if (abs_level <= rl->max_level[last][run]*2) {
1105                                             av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1106                                             return -1;
1107                                         }
1108                                         if (run1 >= 0 && abs_level <= rl->max_level[last][run1]) {
1109                                             av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1110                                             return -1;
1111                                         }
1112                                     }
1113                                 }
1114                             }
1115 #endif
1116                             if (level > 0)
1117                                 level = level * qmul + qadd;
1118                             else
1119                                 level = level * qmul - qadd;
1120
1121                             if ((unsigned)(level + 2048) > 4095) {
1122                                 if (s->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) {
1123                                     if (level > 2560 || level < -2560) {
1124                                         av_log(s->avctx, AV_LOG_ERROR,
1125                                                "|level| overflow in 3. esc, qp=%d\n",
1126                                                s->qscale);
1127                                         return -1;
1128                                     }
1129                                 }
1130                                 level = level < 0 ? -2048 : 2047;
1131                             }
1132
1133                             i += run + 1;
1134                             if (last)
1135                                 i += 192;
1136                         } else {
1137                             /* second escape */
1138                             SKIP_BITS(re, &s->gb, 2);
1139                             GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1140                             i    += run + rl->max_run[run >> 7][level / qmul] + 1;  // FIXME opt indexing
1141                             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1142                             LAST_SKIP_BITS(re, &s->gb, 1);
1143                         }
1144                     } else {
1145                         /* first escape */
1146                         SKIP_BITS(re, &s->gb, 1);
1147                         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1148                         i    += run;
1149                         level = level + rl->max_level[run >> 7][(run - 1) & 63] * qmul;  // FIXME opt indexing
1150                         level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1151                         LAST_SKIP_BITS(re, &s->gb, 1);
1152                     }
1153                 }
1154             } else {
1155                 i    += run;
1156                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1157                 LAST_SKIP_BITS(re, &s->gb, 1);
1158             }
1159             if (i > 62) {
1160                 i -= 192;
1161                 if (i & (~63)) {
1162                     av_log(s->avctx, AV_LOG_ERROR,
1163                            "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1164                     return -1;
1165                 }
1166
1167                 block[scan_table[i]] = level;
1168                 break;
1169             }
1170
1171             block[scan_table[i]] = level;
1172         }
1173         CLOSE_READER(re, &s->gb);
1174     }
1175
1176 not_coded:
1177     if (intra) {
1178         if (!s->use_intra_dc_vlc) {
1179             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
1180
1181             i -= i >> 31;  // if (i == -1) i = 0;
1182         }
1183
1184         ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1185         if (s->ac_pred)
1186             i = 63;  // FIXME not optimal
1187     }
1188     s->block_last_index[n] = i;
1189     return 0;
1190 }
1191
1192 /**
1193  * decode partition C of one MB.
1194  * @return <0 if an error occurred
1195  */
1196 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
1197 {
1198     int cbp, mb_type;
1199     const int xy = s->mb_x + s->mb_y * s->mb_stride;
1200
1201     mb_type = s->current_picture.mb_type[xy];
1202     cbp     = s->cbp_table[xy];
1203
1204     s->use_intra_dc_vlc = s->qscale < s->intra_dc_threshold;
1205
1206     if (s->current_picture.qscale_table[xy] != s->qscale)
1207         ff_set_qscale(s, s->current_picture.qscale_table[xy]);
1208
1209     if (s->pict_type == AV_PICTURE_TYPE_P ||
1210         s->pict_type == AV_PICTURE_TYPE_S) {
1211         int i;
1212         for (i = 0; i < 4; i++) {
1213             s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
1214             s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
1215         }
1216         s->mb_intra = IS_INTRA(mb_type);
1217
1218         if (IS_SKIP(mb_type)) {
1219             /* skip mb */
1220             for (i = 0; i < 6; i++)
1221                 s->block_last_index[i] = -1;
1222             s->mv_dir  = MV_DIR_FORWARD;
1223             s->mv_type = MV_TYPE_16X16;
1224             if (s->pict_type == AV_PICTURE_TYPE_S
1225                 && s->vol_sprite_usage == GMC_SPRITE) {
1226                 s->mcsel      = 1;
1227                 s->mb_skipped = 0;
1228             } else {
1229                 s->mcsel      = 0;
1230                 s->mb_skipped = 1;
1231             }
1232         } else if (s->mb_intra) {
1233             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
1234         } else if (!s->mb_intra) {
1235             // s->mcsel = 0;  // FIXME do we need to init that?
1236
1237             s->mv_dir = MV_DIR_FORWARD;
1238             if (IS_8X8(mb_type)) {
1239                 s->mv_type = MV_TYPE_8X8;
1240             } else {
1241                 s->mv_type = MV_TYPE_16X16;
1242             }
1243         }
1244     } else { /* I-Frame */
1245         s->mb_intra = 1;
1246         s->ac_pred  = IS_ACPRED(s->current_picture.mb_type[xy]);
1247     }
1248
1249     if (!IS_SKIP(mb_type)) {
1250         int i;
1251         s->dsp.clear_blocks(s->block[0]);
1252         /* decode each block */
1253         for (i = 0; i < 6; i++) {
1254             if (mpeg4_decode_block(s, block[i], i, cbp & 32, s->mb_intra, s->rvlc) < 0) {
1255                 av_log(s->avctx, AV_LOG_ERROR,
1256                        "texture corrupted at %d %d %d\n",
1257                        s->mb_x, s->mb_y, s->mb_intra);
1258                 return -1;
1259             }
1260             cbp += cbp;
1261         }
1262     }
1263
1264     /* per-MB end of slice check */
1265     if (--s->mb_num_left <= 0) {
1266         if (mpeg4_is_resync(s))
1267             return SLICE_END;
1268         else
1269             return SLICE_NOEND;
1270     } else {
1271         if (mpeg4_is_resync(s)) {
1272             const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
1273             if (s->cbp_table[xy + delta])
1274                 return SLICE_END;
1275         }
1276         return SLICE_OK;
1277     }
1278 }
1279
1280 static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
1281 {
1282     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1283     int16_t *mot_val;
1284     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
1285     const int xy = s->mb_x + s->mb_y * s->mb_stride;
1286
1287     av_assert2(s->h263_pred);
1288
1289     if (s->pict_type == AV_PICTURE_TYPE_P ||
1290         s->pict_type == AV_PICTURE_TYPE_S) {
1291         do {
1292             if (get_bits1(&s->gb)) {
1293                 /* skip mb */
1294                 s->mb_intra = 0;
1295                 for (i = 0; i < 6; i++)
1296                     s->block_last_index[i] = -1;
1297                 s->mv_dir  = MV_DIR_FORWARD;
1298                 s->mv_type = MV_TYPE_16X16;
1299                 if (s->pict_type == AV_PICTURE_TYPE_S &&
1300                     s->vol_sprite_usage == GMC_SPRITE) {
1301                     s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
1302                                                      MB_TYPE_GMC   |
1303                                                      MB_TYPE_16x16 |
1304                                                      MB_TYPE_L0;
1305                     s->mcsel       = 1;
1306                     s->mv[0][0][0] = get_amv(s, 0);
1307                     s->mv[0][0][1] = get_amv(s, 1);
1308                     s->mb_skipped  = 0;
1309                 } else {
1310                     s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
1311                                                      MB_TYPE_16x16 |
1312                                                      MB_TYPE_L0;
1313                     s->mcsel       = 0;
1314                     s->mv[0][0][0] = 0;
1315                     s->mv[0][0][1] = 0;
1316                     s->mb_skipped  = 1;
1317                 }
1318                 goto end;
1319             }
1320             cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1321             if (cbpc < 0) {
1322                 av_log(s->avctx, AV_LOG_ERROR,
1323                        "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1324                 return -1;
1325             }
1326         } while (cbpc == 20);
1327
1328         s->dsp.clear_blocks(s->block[0]);
1329         dquant      = cbpc & 8;
1330         s->mb_intra = ((cbpc & 4) != 0);
1331         if (s->mb_intra)
1332             goto intra;
1333
1334         if (s->pict_type == AV_PICTURE_TYPE_S &&
1335             s->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
1336             s->mcsel = get_bits1(&s->gb);
1337         else
1338             s->mcsel = 0;
1339         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
1340
1341         cbp = (cbpc & 3) | (cbpy << 2);
1342         if (dquant)
1343             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1344         if ((!s->progressive_sequence) &&
1345             (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE)))
1346             s->interlaced_dct = get_bits1(&s->gb);
1347
1348         s->mv_dir = MV_DIR_FORWARD;
1349         if ((cbpc & 16) == 0) {
1350             if (s->mcsel) {
1351                 s->current_picture.mb_type[xy] = MB_TYPE_GMC   |
1352                                                  MB_TYPE_16x16 |
1353                                                  MB_TYPE_L0;
1354                 /* 16x16 global motion prediction */
1355                 s->mv_type     = MV_TYPE_16X16;
1356                 mx             = get_amv(s, 0);
1357                 my             = get_amv(s, 1);
1358                 s->mv[0][0][0] = mx;
1359                 s->mv[0][0][1] = my;
1360             } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
1361                 s->current_picture.mb_type[xy] = MB_TYPE_16x8 |
1362                                                  MB_TYPE_L0   |
1363                                                  MB_TYPE_INTERLACED;
1364                 /* 16x8 field motion prediction */
1365                 s->mv_type = MV_TYPE_FIELD;
1366
1367                 s->field_select[0][0] = get_bits1(&s->gb);
1368                 s->field_select[0][1] = get_bits1(&s->gb);
1369
1370                 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1371
1372                 for (i = 0; i < 2; i++) {
1373                     mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1374                     if (mx >= 0xffff)
1375                         return -1;
1376
1377                     my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
1378                     if (my >= 0xffff)
1379                         return -1;
1380
1381                     s->mv[0][i][0] = mx;
1382                     s->mv[0][i][1] = my;
1383                 }
1384             } else {
1385                 s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
1386                 /* 16x16 motion prediction */
1387                 s->mv_type = MV_TYPE_16X16;
1388                 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1389                 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1390
1391                 if (mx >= 0xffff)
1392                     return -1;
1393
1394                 my = ff_h263_decode_motion(s, pred_y, s->f_code);
1395
1396                 if (my >= 0xffff)
1397                     return -1;
1398                 s->mv[0][0][0] = mx;
1399                 s->mv[0][0][1] = my;
1400             }
1401         } else {
1402             s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
1403             s->mv_type                     = MV_TYPE_8X8;
1404             for (i = 0; i < 4; i++) {
1405                 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1406                 mx      = ff_h263_decode_motion(s, pred_x, s->f_code);
1407                 if (mx >= 0xffff)
1408                     return -1;
1409
1410                 my = ff_h263_decode_motion(s, pred_y, s->f_code);
1411                 if (my >= 0xffff)
1412                     return -1;
1413                 s->mv[0][i][0] = mx;
1414                 s->mv[0][i][1] = my;
1415                 mot_val[0]     = mx;
1416                 mot_val[1]     = my;
1417             }
1418         }
1419     } else if (s->pict_type == AV_PICTURE_TYPE_B) {
1420         int modb1;   // first bit of modb
1421         int modb2;   // second bit of modb
1422         int mb_type;
1423
1424         s->mb_intra = 0;  // B-frames never contain intra blocks
1425         s->mcsel    = 0;  //      ...               true gmc blocks
1426
1427         if (s->mb_x == 0) {
1428             for (i = 0; i < 2; i++) {
1429                 s->last_mv[i][0][0] =
1430                 s->last_mv[i][0][1] =
1431                 s->last_mv[i][1][0] =
1432                 s->last_mv[i][1][1] = 0;
1433             }
1434
1435             ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);
1436         }
1437
1438         /* if we skipped it in the future P Frame than skip it now too */
1439         s->mb_skipped = s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x];  // Note, skiptab=0 if last was GMC
1440
1441         if (s->mb_skipped) {
1442             /* skip mb */
1443             for (i = 0; i < 6; i++)
1444                 s->block_last_index[i] = -1;
1445
1446             s->mv_dir      = MV_DIR_FORWARD;
1447             s->mv_type     = MV_TYPE_16X16;
1448             s->mv[0][0][0] =
1449             s->mv[0][0][1] =
1450             s->mv[1][0][0] =
1451             s->mv[1][0][1] = 0;
1452             s->current_picture.mb_type[xy] = MB_TYPE_SKIP  |
1453                                              MB_TYPE_16x16 |
1454                                              MB_TYPE_L0;
1455             goto end;
1456         }
1457
1458         modb1 = get_bits1(&s->gb);
1459         if (modb1) {
1460             // like MB_TYPE_B_DIRECT but no vectors coded
1461             mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1;
1462             cbp     = 0;
1463         } else {
1464             modb2   = get_bits1(&s->gb);
1465             mb_type = get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
1466             if (mb_type < 0) {
1467                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
1468                 return -1;
1469             }
1470             mb_type = mb_type_b_map[mb_type];
1471             if (modb2) {
1472                 cbp = 0;
1473             } else {
1474                 s->dsp.clear_blocks(s->block[0]);
1475                 cbp = get_bits(&s->gb, 6);
1476             }
1477
1478             if ((!IS_DIRECT(mb_type)) && cbp) {
1479                 if (get_bits1(&s->gb))
1480                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2);
1481             }
1482
1483             if (!s->progressive_sequence) {
1484                 if (cbp)
1485                     s->interlaced_dct = get_bits1(&s->gb);
1486
1487                 if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) {
1488                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1489                     mb_type &= ~MB_TYPE_16x16;
1490
1491                     if (USES_LIST(mb_type, 0)) {
1492                         s->field_select[0][0] = get_bits1(&s->gb);
1493                         s->field_select[0][1] = get_bits1(&s->gb);
1494                     }
1495                     if (USES_LIST(mb_type, 1)) {
1496                         s->field_select[1][0] = get_bits1(&s->gb);
1497                         s->field_select[1][1] = get_bits1(&s->gb);
1498                     }
1499                 }
1500             }
1501
1502             s->mv_dir = 0;
1503             if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) {
1504                 s->mv_type = MV_TYPE_16X16;
1505
1506                 if (USES_LIST(mb_type, 0)) {
1507                     s->mv_dir = MV_DIR_FORWARD;
1508
1509                     mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1510                     my = ff_h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1511                     s->last_mv[0][1][0] =
1512                     s->last_mv[0][0][0] =
1513                     s->mv[0][0][0]      = mx;
1514                     s->last_mv[0][1][1] =
1515                     s->last_mv[0][0][1] =
1516                     s->mv[0][0][1]      = my;
1517                 }
1518
1519                 if (USES_LIST(mb_type, 1)) {
1520                     s->mv_dir |= MV_DIR_BACKWARD;
1521
1522                     mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1523                     my = ff_h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1524                     s->last_mv[1][1][0] =
1525                     s->last_mv[1][0][0] =
1526                     s->mv[1][0][0]      = mx;
1527                     s->last_mv[1][1][1] =
1528                     s->last_mv[1][0][1] =
1529                     s->mv[1][0][1]      = my;
1530                 }
1531             } else if (!IS_DIRECT(mb_type)) {
1532                 s->mv_type = MV_TYPE_FIELD;
1533
1534                 if (USES_LIST(mb_type, 0)) {
1535                     s->mv_dir = MV_DIR_FORWARD;
1536
1537                     for (i = 0; i < 2; i++) {
1538                         mx = ff_h263_decode_motion(s, s->last_mv[0][i][0], s->f_code);
1539                         my = ff_h263_decode_motion(s, s->last_mv[0][i][1] / 2, s->f_code);
1540                         s->last_mv[0][i][0] =
1541                         s->mv[0][i][0]      = mx;
1542                         s->last_mv[0][i][1] = (s->mv[0][i][1] = my) * 2;
1543                     }
1544                 }
1545
1546                 if (USES_LIST(mb_type, 1)) {
1547                     s->mv_dir |= MV_DIR_BACKWARD;
1548
1549                     for (i = 0; i < 2; i++) {
1550                         mx = ff_h263_decode_motion(s, s->last_mv[1][i][0], s->b_code);
1551                         my = ff_h263_decode_motion(s, s->last_mv[1][i][1] / 2, s->b_code);
1552                         s->last_mv[1][i][0] =
1553                         s->mv[1][i][0]      = mx;
1554                         s->last_mv[1][i][1] = (s->mv[1][i][1] = my) * 2;
1555                     }
1556                 }
1557             }
1558         }
1559
1560         if (IS_DIRECT(mb_type)) {
1561             if (IS_SKIP(mb_type)) {
1562                 mx =
1563                 my = 0;
1564             } else {
1565                 mx = ff_h263_decode_motion(s, 0, 1);
1566                 my = ff_h263_decode_motion(s, 0, 1);
1567             }
1568
1569             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1570             mb_type  |= ff_mpeg4_set_direct_mv(s, mx, my);
1571         }
1572         s->current_picture.mb_type[xy] = mb_type;
1573     } else { /* I-Frame */
1574         do {
1575             cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1576             if (cbpc < 0) {
1577                 av_log(s->avctx, AV_LOG_ERROR,
1578                        "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1579                 return -1;
1580             }
1581         } while (cbpc == 8);
1582
1583         dquant = cbpc & 4;
1584         s->mb_intra = 1;
1585
1586 intra:
1587         s->ac_pred = get_bits1(&s->gb);
1588         if (s->ac_pred)
1589             s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1590         else
1591             s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1592
1593         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1594         if (cbpy < 0) {
1595             av_log(s->avctx, AV_LOG_ERROR,
1596                    "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1597             return -1;
1598         }
1599         cbp = (cbpc & 3) | (cbpy << 2);
1600
1601         s->use_intra_dc_vlc = s->qscale < s->intra_dc_threshold;
1602
1603         if (dquant)
1604             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1605
1606         if (!s->progressive_sequence)
1607             s->interlaced_dct = get_bits1(&s->gb);
1608
1609         s->dsp.clear_blocks(s->block[0]);
1610         /* decode each block */
1611         for (i = 0; i < 6; i++) {
1612             if (mpeg4_decode_block(s, block[i], i, cbp & 32, 1, 0) < 0)
1613                 return -1;
1614             cbp += cbp;
1615         }
1616         goto end;
1617     }
1618
1619     /* decode each block */
1620     for (i = 0; i < 6; i++) {
1621         if (mpeg4_decode_block(s, block[i], i, cbp & 32, 0, 0) < 0)
1622             return -1;
1623         cbp += cbp;
1624     }
1625
1626 end:
1627     /* per-MB end of slice check */
1628     if (s->codec_id == AV_CODEC_ID_MPEG4) {
1629         int next = mpeg4_is_resync(s);
1630         if (next) {
1631             if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
1632                 return -1;
1633             } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
1634                 return SLICE_END;
1635
1636             if (s->pict_type == AV_PICTURE_TYPE_B) {
1637                 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1638                 ff_thread_await_progress(&s->next_picture_ptr->tf,
1639                                          (s->mb_x + delta >= s->mb_width)
1640                                          ? FFMIN(s->mb_y + 1, s->mb_height - 1)
1641                                          : s->mb_y, 0);
1642                 if (s->next_picture.mbskip_table[xy + delta])
1643                     return SLICE_OK;
1644             }
1645
1646             return SLICE_END;
1647         }
1648     }
1649
1650     return SLICE_OK;
1651 }
1652
1653 static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
1654 {
1655     int hours, minutes, seconds;
1656
1657     if (!show_bits(gb, 23)) {
1658         av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
1659         return -1;
1660     }
1661
1662     hours   = get_bits(gb, 5);
1663     minutes = get_bits(gb, 6);
1664     skip_bits1(gb);
1665     seconds = get_bits(gb, 6);
1666
1667     s->time_base = seconds + 60*(minutes + 60*hours);
1668
1669     skip_bits1(gb);
1670     skip_bits1(gb);
1671
1672     return 0;
1673 }
1674
1675 static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb)
1676 {
1677
1678     s->avctx->profile = get_bits(gb, 4);
1679     s->avctx->level   = get_bits(gb, 4);
1680
1681     // for Simple profile, level 0
1682     if (s->avctx->profile == 0 && s->avctx->level == 8) {
1683         s->avctx->level = 0;
1684     }
1685
1686     return 0;
1687 }
1688
1689 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb)
1690 {
1691     int width, height, vo_ver_id;
1692
1693     /* vol header */
1694     skip_bits(gb, 1);                   /* random access */
1695     s->vo_type = get_bits(gb, 8);
1696     if (get_bits1(gb) != 0) {           /* is_ol_id */
1697         vo_ver_id = get_bits(gb, 4);    /* vo_ver_id */
1698         skip_bits(gb, 3);               /* vo_priority */
1699     } else {
1700         vo_ver_id = 1;
1701     }
1702     s->aspect_ratio_info = get_bits(gb, 4);
1703     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
1704         s->avctx->sample_aspect_ratio.num = get_bits(gb, 8);  // par_width
1705         s->avctx->sample_aspect_ratio.den = get_bits(gb, 8);  // par_height
1706     } else {
1707         s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[s->aspect_ratio_info];
1708     }
1709
1710     if ((s->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
1711         int chroma_format = get_bits(gb, 2);
1712         if (chroma_format != CHROMA_420)
1713             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
1714
1715         s->low_delay = get_bits1(gb);
1716         if (get_bits1(gb)) {    /* vbv parameters */
1717             get_bits(gb, 15);   /* first_half_bitrate */
1718             skip_bits1(gb);     /* marker */
1719             get_bits(gb, 15);   /* latter_half_bitrate */
1720             skip_bits1(gb);     /* marker */
1721             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
1722             skip_bits1(gb);     /* marker */
1723             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
1724             get_bits(gb, 11);   /* first_half_vbv_occupancy */
1725             skip_bits1(gb);     /* marker */
1726             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
1727             skip_bits1(gb);     /* marker */
1728         }
1729     } else {
1730         /* is setting low delay flag only once the smartest thing to do?
1731          * low delay detection won't be overriden. */
1732         if (s->picture_number == 0)
1733             s->low_delay = 0;
1734     }
1735
1736     s->shape = get_bits(gb, 2); /* vol shape */
1737     if (s->shape != RECT_SHAPE)
1738         av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
1739     if (s->shape == GRAY_SHAPE && vo_ver_id != 1) {
1740         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
1741         skip_bits(gb, 4);  /* video_object_layer_shape_extension */
1742     }
1743
1744     check_marker(gb, "before time_increment_resolution");
1745
1746     s->avctx->time_base.den = get_bits(gb, 16);
1747     if (!s->avctx->time_base.den) {
1748         av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
1749         s->avctx->time_base.num = 0;
1750         return -1;
1751     }
1752
1753     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1754     if (s->time_increment_bits < 1)
1755         s->time_increment_bits = 1;
1756
1757     check_marker(gb, "before fixed_vop_rate");
1758
1759     if (get_bits1(gb) != 0)     /* fixed_vop_rate  */
1760         s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
1761     else
1762         s->avctx->time_base.num = 1;
1763
1764     s->t_frame = 0;
1765
1766     if (s->shape != BIN_ONLY_SHAPE) {
1767         if (s->shape == RECT_SHAPE) {
1768             check_marker(gb, "before width");
1769             width = get_bits(gb, 13);
1770             check_marker(gb, "before height");
1771             height = get_bits(gb, 13);
1772             check_marker(gb, "after height");
1773             if (width && height &&  /* they should be non zero but who knows */
1774                 !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
1775                 if (s->width && s->height &&
1776                     (s->width != width || s->height != height))
1777                     s->context_reinit = 1;
1778                 s->width  = width;
1779                 s->height = height;
1780             }
1781         }
1782
1783         s->progressive_sequence  =
1784         s->progressive_frame     = get_bits1(gb) ^ 1;
1785         s->interlaced_dct        = 0;
1786         if (!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
1787             av_log(s->avctx, AV_LOG_INFO,           /* OBMC Disable */
1788                    "MPEG4 OBMC not supported (very likely buggy encoder)\n");
1789         if (vo_ver_id == 1)
1790             s->vol_sprite_usage = get_bits1(gb);    /* vol_sprite_usage */
1791         else
1792             s->vol_sprite_usage = get_bits(gb, 2);  /* vol_sprite_usage */
1793
1794         if (s->vol_sprite_usage == STATIC_SPRITE)
1795             av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
1796         if (s->vol_sprite_usage == STATIC_SPRITE ||
1797             s->vol_sprite_usage == GMC_SPRITE) {
1798             if (s->vol_sprite_usage == STATIC_SPRITE) {
1799                 s->sprite_width = get_bits(gb, 13);
1800                 skip_bits1(gb); /* marker */
1801                 s->sprite_height = get_bits(gb, 13);
1802                 skip_bits1(gb); /* marker */
1803                 s->sprite_left = get_bits(gb, 13);
1804                 skip_bits1(gb); /* marker */
1805                 s->sprite_top = get_bits(gb, 13);
1806                 skip_bits1(gb); /* marker */
1807             }
1808             s->num_sprite_warping_points = get_bits(gb, 6);
1809             if (s->num_sprite_warping_points > 3) {
1810                 av_log(s->avctx, AV_LOG_ERROR,
1811                        "%d sprite_warping_points\n",
1812                        s->num_sprite_warping_points);
1813                 s->num_sprite_warping_points = 0;
1814                 return -1;
1815             }
1816             s->sprite_warping_accuracy  = get_bits(gb, 2);
1817             s->sprite_brightness_change = get_bits1(gb);
1818             if (s->vol_sprite_usage == STATIC_SPRITE)
1819                 s->low_latency_sprite = get_bits1(gb);
1820         }
1821         // FIXME sadct disable bit if verid!=1 && shape not rect
1822
1823         if (get_bits1(gb) == 1) {                   /* not_8_bit */
1824             s->quant_precision = get_bits(gb, 4);   /* quant_precision */
1825             if (get_bits(gb, 4) != 8)               /* bits_per_pixel */
1826                 av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
1827             if (s->quant_precision != 5)
1828                 av_log(s->avctx, AV_LOG_ERROR,
1829                        "quant precision %d\n", s->quant_precision);
1830             if (s->quant_precision<3 || s->quant_precision>9) {
1831                 s->quant_precision = 5;
1832             }
1833         } else {
1834             s->quant_precision = 5;
1835         }
1836
1837         // FIXME a bunch of grayscale shape things
1838
1839         if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
1840             int i, v;
1841
1842             /* load default matrixes */
1843             for (i = 0; i < 64; i++) {
1844                 int j = s->dsp.idct_permutation[i];
1845                 v = ff_mpeg4_default_intra_matrix[i];
1846                 s->intra_matrix[j]        = v;
1847                 s->chroma_intra_matrix[j] = v;
1848
1849                 v = ff_mpeg4_default_non_intra_matrix[i];
1850                 s->inter_matrix[j]        = v;
1851                 s->chroma_inter_matrix[j] = v;
1852             }
1853
1854             /* load custom intra matrix */
1855             if (get_bits1(gb)) {
1856                 int last = 0;
1857                 for (i = 0; i < 64; i++) {
1858                     int j;
1859                     v = get_bits(gb, 8);
1860                     if (v == 0)
1861                         break;
1862
1863                     last = v;
1864                     j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
1865                     s->intra_matrix[j]        = last;
1866                     s->chroma_intra_matrix[j] = last;
1867                 }
1868
1869                 /* replicate last value */
1870                 for (; i < 64; i++) {
1871                     int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
1872                     s->intra_matrix[j]        = last;
1873                     s->chroma_intra_matrix[j] = last;
1874                 }
1875             }
1876
1877             /* load custom non intra matrix */
1878             if (get_bits1(gb)) {
1879                 int last = 0;
1880                 for (i = 0; i < 64; i++) {
1881                     int j;
1882                     v = get_bits(gb, 8);
1883                     if (v == 0)
1884                         break;
1885
1886                     last = v;
1887                     j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
1888                     s->inter_matrix[j]        = v;
1889                     s->chroma_inter_matrix[j] = v;
1890                 }
1891
1892                 /* replicate last value */
1893                 for (; i < 64; i++) {
1894                     int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
1895                     s->inter_matrix[j]        = last;
1896                     s->chroma_inter_matrix[j] = last;
1897                 }
1898             }
1899
1900             // FIXME a bunch of grayscale shape things
1901         }
1902
1903         if (vo_ver_id != 1)
1904             s->quarter_sample = get_bits1(gb);
1905         else
1906             s->quarter_sample = 0;
1907
1908         if (!get_bits1(gb)) {
1909             int pos               = get_bits_count(gb);
1910             int estimation_method = get_bits(gb, 2);
1911             if (estimation_method < 2) {
1912                 if (!get_bits1(gb)) {
1913                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* opaque */
1914                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* transparent */
1915                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* intra_cae */
1916                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* inter_cae */
1917                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* no_update */
1918                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* upampling */
1919                 }
1920                 if (!get_bits1(gb)) {
1921                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* intra_blocks */
1922                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* inter_blocks */
1923                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* inter4v_blocks */
1924                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* not coded blocks */
1925                 }
1926                 if (!check_marker(gb, "in complexity estimation part 1")) {
1927                     skip_bits_long(gb, pos - get_bits_count(gb));
1928                     goto no_cplx_est;
1929                 }
1930                 if (!get_bits1(gb)) {
1931                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* dct_coeffs */
1932                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* dct_lines */
1933                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* vlc_syms */
1934                     s->cplx_estimation_trash_i += 4 * get_bits1(gb);  /* vlc_bits */
1935                 }
1936                 if (!get_bits1(gb)) {
1937                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* apm */
1938                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* npm */
1939                     s->cplx_estimation_trash_b += 8 * get_bits1(gb);  /* interpolate_mc_q */
1940                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* forwback_mc_q */
1941                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* halfpel2 */
1942                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* halfpel4 */
1943                 }
1944                 if (!check_marker(gb, "in complexity estimation part 2")) {
1945                     skip_bits_long(gb, pos - get_bits_count(gb));
1946                     goto no_cplx_est;
1947                 }
1948                 if (estimation_method == 1) {
1949                     s->cplx_estimation_trash_i += 8 * get_bits1(gb);  /* sadct */
1950                     s->cplx_estimation_trash_p += 8 * get_bits1(gb);  /* qpel */
1951                 }
1952             } else
1953                 av_log(s->avctx, AV_LOG_ERROR,
1954                        "Invalid Complexity estimation method %d\n",
1955                        estimation_method);
1956         } else {
1957
1958 no_cplx_est:
1959             s->cplx_estimation_trash_i =
1960             s->cplx_estimation_trash_p =
1961             s->cplx_estimation_trash_b = 0;
1962         }
1963
1964         s->resync_marker = !get_bits1(gb); /* resync_marker_disabled */
1965
1966         s->data_partitioning = get_bits1(gb);
1967         if (s->data_partitioning)
1968             s->rvlc = get_bits1(gb);
1969
1970         if (vo_ver_id != 1) {
1971             s->new_pred = get_bits1(gb);
1972             if (s->new_pred) {
1973                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
1974                 skip_bits(gb, 2); /* requested upstream message type */
1975                 skip_bits1(gb);   /* newpred segment type */
1976             }
1977             s->reduced_res_vop = get_bits1(gb);
1978             if (s->reduced_res_vop)
1979                 av_log(s->avctx, AV_LOG_ERROR,
1980                        "reduced resolution VOP not supported\n");
1981         } else {
1982             s->new_pred        = 0;
1983             s->reduced_res_vop = 0;
1984         }
1985
1986         s->scalability = get_bits1(gb);
1987
1988         if (s->scalability) {
1989             GetBitContext bak = *gb;
1990             int h_sampling_factor_n;
1991             int h_sampling_factor_m;
1992             int v_sampling_factor_n;
1993             int v_sampling_factor_m;
1994
1995             s->hierachy_type = get_bits1(gb);
1996             skip_bits(gb, 4);  /* ref_layer_id */
1997             skip_bits1(gb);    /* ref_layer_sampling_dir */
1998             h_sampling_factor_n = get_bits(gb, 5);
1999             h_sampling_factor_m = get_bits(gb, 5);
2000             v_sampling_factor_n = get_bits(gb, 5);
2001             v_sampling_factor_m = get_bits(gb, 5);
2002             s->enhancement_type = get_bits1(gb);
2003
2004             if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
2005                 v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2006                 /* illegal scalability header (VERY broken encoder),
2007                  * trying to workaround */
2008                 s->scalability = 0;
2009                 *gb            = bak;
2010             } else
2011                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
2012
2013             // bin shape stuff FIXME
2014         }
2015     }
2016
2017     if (s->avctx->debug&FF_DEBUG_PICT_INFO) {
2018         av_log(s->avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d,  %s%s%s%s\n",
2019                s->avctx->time_base.num, s->avctx->time_base.den,
2020                s->time_increment_bits,
2021                s->quant_precision,
2022                s->progressive_sequence,
2023                s->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "",
2024                s->data_partitioning ? "partition " : "", s->rvlc ? "rvlc " : ""
2025         );
2026     }
2027
2028     return 0;
2029 }
2030
2031 /**
2032  * Decode the user data stuff in the header.
2033  * Also initializes divx/xvid/lavc_version/build.
2034  */
2035 static int decode_user_data(MpegEncContext *s, GetBitContext *gb)
2036 {
2037     char buf[256];
2038     int i;
2039     int e;
2040     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
2041     char last;
2042
2043     for (i = 0; i < 255 && get_bits_count(gb) < gb->size_in_bits; i++) {
2044         if (show_bits(gb, 23) == 0)
2045             break;
2046         buf[i] = get_bits(gb, 8);
2047     }
2048     buf[i] = 0;
2049
2050     /* divx detection */
2051     e = sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
2052     if (e < 2)
2053         e = sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
2054     if (e >= 2) {
2055         s->divx_version = ver;
2056         s->divx_build   = build;
2057         s->divx_packed  = e == 3 && last == 'p';
2058         if (s->divx_packed && !s->showed_packed_warning) {
2059             av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and "
2060                    "wasteful way to store B-frames ('packed B-frames'). "
2061                    "Consider using a tool like VirtualDub or avidemux to fix it.\n");
2062             s->showed_packed_warning = 1;
2063         }
2064     }
2065
2066     /* libavcodec detection */
2067     e = sscanf(buf, "FFmpe%*[^b]b%d", &build) + 3;
2068     if (e != 4)
2069         e = sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
2070     if (e != 4) {
2071         e = sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1;
2072         if (e > 1)
2073             build = (ver << 16) + (ver2 << 8) + ver3;
2074     }
2075     if (e != 4) {
2076         if (strcmp(buf, "ffmpeg") == 0)
2077             s->lavc_build = 4600;
2078     }
2079     if (e == 4)
2080         s->lavc_build = build;
2081
2082     /* Xvid detection */
2083     e = sscanf(buf, "XviD%d", &build);
2084     if (e == 1)
2085         s->xvid_build = build;
2086
2087     return 0;
2088 }
2089
2090 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb)
2091 {
2092     int time_incr, time_increment;
2093     int64_t pts;
2094
2095     s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;        /* pict type: I = 0 , P = 1 */
2096     if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
2097         s->vol_control_parameters == 0 && !(s->flags & CODEC_FLAG_LOW_DELAY)) {
2098         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
2099         s->low_delay = 0;
2100     }
2101
2102     s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
2103     if (s->partitioned_frame)
2104         s->decode_mb = mpeg4_decode_partitioned_mb;
2105     else
2106         s->decode_mb = mpeg4_decode_mb;
2107
2108     time_incr = 0;
2109     while (get_bits1(gb) != 0)
2110         time_incr++;
2111
2112     check_marker(gb, "before time_increment");
2113
2114     if (s->time_increment_bits == 0 ||
2115         !(show_bits(gb, s->time_increment_bits + 1) & 1)) {
2116         av_log(s->avctx, AV_LOG_ERROR,
2117                "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
2118
2119         for (s->time_increment_bits = 1;
2120              s->time_increment_bits < 16;
2121              s->time_increment_bits++) {
2122             if (s->pict_type == AV_PICTURE_TYPE_P ||
2123                 (s->pict_type == AV_PICTURE_TYPE_S &&
2124                  s->vol_sprite_usage == GMC_SPRITE)) {
2125                 if ((show_bits(gb, s->time_increment_bits + 6) & 0x37) == 0x30)
2126                     break;
2127             } else if ((show_bits(gb, s->time_increment_bits + 5) & 0x1F) == 0x18)
2128                 break;
2129         }
2130
2131         av_log(s->avctx, AV_LOG_ERROR,
2132                "my guess is %d bits ;)\n", s->time_increment_bits);
2133         if (s->avctx->time_base.den && 4*s->avctx->time_base.den < 1<<s->time_increment_bits) {
2134             s->avctx->time_base.den = 1<<s->time_increment_bits;
2135         }
2136     }
2137
2138     if (IS_3IV1)
2139         time_increment = get_bits1(gb);        // FIXME investigate further
2140     else
2141         time_increment = get_bits(gb, s->time_increment_bits);
2142
2143     if (s->pict_type != AV_PICTURE_TYPE_B) {
2144         s->last_time_base = s->time_base;
2145         s->time_base     += time_incr;
2146         s->time = s->time_base * s->avctx->time_base.den + time_increment;
2147         if (s->workaround_bugs & FF_BUG_UMP4) {
2148             if (s->time < s->last_non_b_time) {
2149                 /* header is not mpeg-4-compatible, broken encoder,
2150                  * trying to workaround */
2151                 s->time_base++;
2152                 s->time += s->avctx->time_base.den;
2153             }
2154         }
2155         s->pp_time         = s->time - s->last_non_b_time;
2156         s->last_non_b_time = s->time;
2157     } else {
2158         s->time    = (s->last_time_base + time_incr) * s->avctx->time_base.den + time_increment;
2159         s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
2160         if (s->pp_time <= s->pb_time ||
2161             s->pp_time <= s->pp_time - s->pb_time ||
2162             s->pp_time <= 0) {
2163             /* messed up order, maybe after seeking? skipping current b-frame */
2164             return FRAME_SKIPPED;
2165         }
2166         ff_mpeg4_init_direct_mv(s);
2167
2168         if (s->t_frame == 0)
2169             s->t_frame = s->pb_time;
2170         if (s->t_frame == 0)
2171             s->t_frame = 1;  // 1/0 protection
2172         s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, s->t_frame) -
2173                             ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame)) * 2;
2174         s->pb_field_time = (ROUNDED_DIV(s->time, s->t_frame) -
2175                             ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame)) * 2;
2176         if (!s->progressive_sequence) {
2177             if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
2178                 return FRAME_SKIPPED;
2179         }
2180     }
2181
2182     if (s->avctx->time_base.num)
2183         pts = ROUNDED_DIV(s->time, s->avctx->time_base.num);
2184     else
2185         pts = AV_NOPTS_VALUE;
2186     if (s->avctx->debug&FF_DEBUG_PTS)
2187         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
2188                pts);
2189
2190     check_marker(gb, "before vop_coded");
2191
2192     /* vop coded */
2193     if (get_bits1(gb) != 1) {
2194         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2195             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
2196         return FRAME_SKIPPED;
2197     }
2198     if (s->new_pred)
2199         decode_new_pred(s, gb);
2200
2201     if (s->shape != BIN_ONLY_SHAPE &&
2202                     (s->pict_type == AV_PICTURE_TYPE_P ||
2203                      (s->pict_type == AV_PICTURE_TYPE_S &&
2204                       s->vol_sprite_usage == GMC_SPRITE))) {
2205         /* rounding type for motion estimation */
2206         s->no_rounding = get_bits1(gb);
2207     } else {
2208         s->no_rounding = 0;
2209     }
2210     // FIXME reduced res stuff
2211
2212     if (s->shape != RECT_SHAPE) {
2213         if (s->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
2214             skip_bits(gb, 13);  /* width */
2215             skip_bits1(gb);     /* marker */
2216             skip_bits(gb, 13);  /* height */
2217             skip_bits1(gb);     /* marker */
2218             skip_bits(gb, 13);  /* hor_spat_ref */
2219             skip_bits1(gb);     /* marker */
2220             skip_bits(gb, 13);  /* ver_spat_ref */
2221         }
2222         skip_bits1(gb);         /* change_CR_disable */
2223
2224         if (get_bits1(gb) != 0)
2225             skip_bits(gb, 8);   /* constant_alpha_value */
2226     }
2227
2228     // FIXME complexity estimation stuff
2229
2230     if (s->shape != BIN_ONLY_SHAPE) {
2231         skip_bits_long(gb, s->cplx_estimation_trash_i);
2232         if (s->pict_type != AV_PICTURE_TYPE_I)
2233             skip_bits_long(gb, s->cplx_estimation_trash_p);
2234         if (s->pict_type == AV_PICTURE_TYPE_B)
2235             skip_bits_long(gb, s->cplx_estimation_trash_b);
2236
2237         if (get_bits_left(gb) < 3) {
2238             av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
2239             return -1;
2240         }
2241         s->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
2242         if (!s->progressive_sequence) {
2243             s->top_field_first = get_bits1(gb);
2244             s->alternate_scan  = get_bits1(gb);
2245         } else
2246             s->alternate_scan = 0;
2247     }
2248
2249     if (s->alternate_scan) {
2250         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
2251         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
2252         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
2253         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
2254     } else {
2255         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
2256         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
2257         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
2258         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
2259     }
2260
2261     if (s->pict_type == AV_PICTURE_TYPE_S &&
2262         (s->vol_sprite_usage == STATIC_SPRITE ||
2263          s->vol_sprite_usage == GMC_SPRITE)) {
2264         if (mpeg4_decode_sprite_trajectory(s, gb) < 0)
2265             return AVERROR_INVALIDDATA;
2266         if (s->sprite_brightness_change)
2267             av_log(s->avctx, AV_LOG_ERROR,
2268                    "sprite_brightness_change not supported\n");
2269         if (s->vol_sprite_usage == STATIC_SPRITE)
2270             av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
2271     }
2272
2273     if (s->shape != BIN_ONLY_SHAPE) {
2274         s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
2275         if (s->qscale == 0) {
2276             av_log(s->avctx, AV_LOG_ERROR,
2277                    "Error, header damaged or not MPEG4 header (qscale=0)\n");
2278             return -1;  // makes no sense to continue, as there is nothing left from the image then
2279         }
2280
2281         if (s->pict_type != AV_PICTURE_TYPE_I) {
2282             s->f_code = get_bits(gb, 3);        /* fcode_for */
2283             if (s->f_code == 0) {
2284                 av_log(s->avctx, AV_LOG_ERROR,
2285                        "Error, header damaged or not MPEG4 header (f_code=0)\n");
2286                 s->f_code = 1;
2287                 return -1;  // makes no sense to continue, as there is nothing left from the image then
2288             }
2289         } else
2290             s->f_code = 1;
2291
2292         if (s->pict_type == AV_PICTURE_TYPE_B) {
2293             s->b_code = get_bits(gb, 3);
2294             if (s->b_code == 0) {
2295                 av_log(s->avctx, AV_LOG_ERROR,
2296                        "Error, header damaged or not MPEG4 header (b_code=0)\n");
2297                 s->b_code=1;
2298                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2299             }
2300         } else
2301             s->b_code = 1;
2302
2303         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2304             av_log(s->avctx, AV_LOG_DEBUG,
2305                    "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",
2306                    s->qscale, s->f_code, s->b_code,
2307                    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")),
2308                    gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
2309                    s->top_field_first, s->quarter_sample ? "q" : "h",
2310                    s->data_partitioning, s->resync_marker,
2311                    s->num_sprite_warping_points, s->sprite_warping_accuracy,
2312                    1 - s->no_rounding, s->vo_type,
2313                    s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold,
2314                    s->cplx_estimation_trash_i, s->cplx_estimation_trash_p,
2315                    s->cplx_estimation_trash_b,
2316                    s->time,
2317                    time_increment
2318                   );
2319         }
2320
2321         if (!s->scalability) {
2322             if (s->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
2323                 skip_bits1(gb);  // vop shape coding type
2324         } else {
2325             if (s->enhancement_type) {
2326                 int load_backward_shape = get_bits1(gb);
2327                 if (load_backward_shape)
2328                     av_log(s->avctx, AV_LOG_ERROR,
2329                            "load backward shape isn't supported\n");
2330             }
2331             skip_bits(gb, 2);  // ref_select_code
2332         }
2333     }
2334     /* detect buggy encoders which don't set the low_delay flag
2335      * (divx4/xvid/opendivx). Note we cannot detect divx5 without b-frames
2336      * easily (although it's buggy too) */
2337     if (s->vo_type == 0 && s->vol_control_parameters == 0 &&
2338         s->divx_version == -1 && s->picture_number == 0) {
2339         av_log(s->avctx, AV_LOG_WARNING,
2340                "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
2341         s->low_delay = 1;
2342     }
2343
2344     s->picture_number++;  // better than pic number==0 always ;)
2345
2346     // FIXME add short header support
2347     s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
2348     s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;
2349
2350     if (s->workaround_bugs & FF_BUG_EDGE) {
2351         s->h_edge_pos = s->width;
2352         s->v_edge_pos = s->height;
2353     }
2354     return 0;
2355 }
2356
2357 /**
2358  * Decode mpeg4 headers.
2359  * @return <0 if no VOP found (or a damaged one)
2360  *         FRAME_SKIPPED if a not coded VOP is found
2361  *         0 if a VOP is found
2362  */
2363 int ff_mpeg4_decode_picture_header(MpegEncContext *s, GetBitContext *gb)
2364 {
2365     unsigned startcode, v;
2366
2367     /* search next start code */
2368     align_get_bits(gb);
2369
2370     if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
2371         skip_bits(gb, 24);
2372         if (get_bits(gb, 8) == 0xF0)
2373             goto end;
2374     }
2375
2376     startcode = 0xff;
2377     for (;;) {
2378         if (get_bits_count(gb) >= gb->size_in_bits) {
2379             if (gb->size_in_bits == 8 &&
2380                 (s->divx_version >= 0 || s->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
2381                 av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
2382                 return FRAME_SKIPPED;  // divx bug
2383             } else
2384                 return -1;  // end of stream
2385         }
2386
2387         /* use the bits after the test */
2388         v = get_bits(gb, 8);
2389         startcode = ((startcode << 8) | v) & 0xffffffff;
2390
2391         if ((startcode & 0xFFFFFF00) != 0x100)
2392             continue;  // no startcode
2393
2394         if (s->avctx->debug & FF_DEBUG_STARTCODE) {
2395             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
2396             if (startcode <= 0x11F)
2397                 av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
2398             else if (startcode <= 0x12F)
2399                 av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
2400             else if (startcode <= 0x13F)
2401                 av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
2402             else if (startcode <= 0x15F)
2403                 av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
2404             else if (startcode <= 0x1AF)
2405                 av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
2406             else if (startcode == 0x1B0)
2407                 av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
2408             else if (startcode == 0x1B1)
2409                 av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
2410             else if (startcode == 0x1B2)
2411                 av_log(s->avctx, AV_LOG_DEBUG, "User Data");
2412             else if (startcode == 0x1B3)
2413                 av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
2414             else if (startcode == 0x1B4)
2415                 av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
2416             else if (startcode == 0x1B5)
2417                 av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
2418             else if (startcode == 0x1B6)
2419                 av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
2420             else if (startcode == 0x1B7)
2421                 av_log(s->avctx, AV_LOG_DEBUG, "slice start");
2422             else if (startcode == 0x1B8)
2423                 av_log(s->avctx, AV_LOG_DEBUG, "extension start");
2424             else if (startcode == 0x1B9)
2425                 av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
2426             else if (startcode == 0x1BA)
2427                 av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
2428             else if (startcode == 0x1BB)
2429                 av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
2430             else if (startcode == 0x1BC)
2431                 av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
2432             else if (startcode == 0x1BD)
2433                 av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
2434             else if (startcode == 0x1BE)
2435                 av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
2436             else if (startcode == 0x1BF)
2437                 av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
2438             else if (startcode == 0x1C0)
2439                 av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
2440             else if (startcode == 0x1C1)
2441                 av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
2442             else if (startcode == 0x1C2)
2443                 av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
2444             else if (startcode == 0x1C3)
2445                 av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
2446             else if (startcode <= 0x1C5)
2447                 av_log(s->avctx, AV_LOG_DEBUG, "reserved");
2448             else if (startcode <= 0x1FF)
2449                 av_log(s->avctx, AV_LOG_DEBUG, "System start");
2450             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
2451         }
2452
2453         if (startcode >= 0x120 && startcode <= 0x12F) {
2454             if (decode_vol_header(s, gb) < 0)
2455                 return -1;
2456         } else if (startcode == USER_DATA_STARTCODE) {
2457             decode_user_data(s, gb);
2458         } else if (startcode == GOP_STARTCODE) {
2459             mpeg4_decode_gop_header(s, gb);
2460         } else if (startcode == VOS_STARTCODE) {
2461             mpeg4_decode_profile_level(s, gb);
2462         } else if (startcode == VOP_STARTCODE) {
2463             break;
2464         }
2465
2466         align_get_bits(gb);
2467         startcode = 0xff;
2468     }
2469
2470 end:
2471     if (s->flags & CODEC_FLAG_LOW_DELAY)
2472         s->low_delay = 1;
2473     s->avctx->has_b_frames = !s->low_delay;
2474
2475     return decode_vop_header(s, gb);
2476 }
2477
2478 av_cold void ff_mpeg4videodec_static_init(void) {
2479     static int done = 0;
2480
2481     if (!done) {
2482         ff_init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
2483         ff_init_rl(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
2484         ff_init_rl(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
2485         INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
2486         INIT_VLC_RL(ff_rvlc_rl_inter, 1072);
2487         INIT_VLC_RL(ff_rvlc_rl_intra, 1072);
2488         INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2489                         &ff_mpeg4_DCtab_lum[0][1], 2, 1,
2490                         &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
2491         INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2492                         &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
2493                         &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
2494         INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2495                         &ff_sprite_trajectory_tab[0][1], 4, 2,
2496                         &ff_sprite_trajectory_tab[0][0], 4, 2, 128);
2497         INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2498                         &ff_mb_type_b_tab[0][1], 2, 1,
2499                         &ff_mb_type_b_tab[0][0], 2, 1, 16);
2500         done = 1;
2501     }
2502 }
2503
2504 static av_cold int decode_init(AVCodecContext *avctx)
2505 {
2506     MpegEncContext *s = avctx->priv_data;
2507     int ret;
2508
2509     s->divx_version =
2510     s->divx_build   =
2511     s->xvid_build   =
2512     s->lavc_build   = -1;
2513
2514     if ((ret = ff_h263_decode_init(avctx)) < 0)
2515         return ret;
2516
2517     ff_mpeg4videodec_static_init();
2518
2519     s->h263_pred = 1;
2520     s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
2521     s->decode_mb = mpeg4_decode_mb;
2522     s->time_increment_bits = 4; /* default value for broken headers */
2523
2524     avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
2525     avctx->internal->allocate_progress = 1;
2526
2527     return 0;
2528 }
2529
2530 static const AVProfile mpeg4_video_profiles[] = {
2531     { FF_PROFILE_MPEG4_SIMPLE,                    "Simple Profile" },
2532     { FF_PROFILE_MPEG4_SIMPLE_SCALABLE,           "Simple Scalable Profile" },
2533     { FF_PROFILE_MPEG4_CORE,                      "Core Profile" },
2534     { FF_PROFILE_MPEG4_MAIN,                      "Main Profile" },
2535     { FF_PROFILE_MPEG4_N_BIT,                     "N-bit Profile" },
2536     { FF_PROFILE_MPEG4_SCALABLE_TEXTURE,          "Scalable Texture Profile" },
2537     { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION,     "Simple Face Animation Profile" },
2538     { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE,    "Basic Animated Texture Profile" },
2539     { FF_PROFILE_MPEG4_HYBRID,                    "Hybrid Profile" },
2540     { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME,        "Advanced Real Time Simple Profile" },
2541     { FF_PROFILE_MPEG4_CORE_SCALABLE,             "Code Scalable Profile" },
2542     { FF_PROFILE_MPEG4_ADVANCED_CODING,           "Advanced Coding Profile" },
2543     { FF_PROFILE_MPEG4_ADVANCED_CORE,             "Advanced Core Profile" },
2544     { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
2545     { FF_PROFILE_MPEG4_SIMPLE_STUDIO,             "Simple Studio Profile" },
2546     { FF_PROFILE_MPEG4_ADVANCED_SIMPLE,           "Advanced Simple Profile" },
2547     { FF_PROFILE_UNKNOWN },
2548 };
2549
2550 static const AVOption mpeg4_options[] = {
2551     {"quarter_sample", "1/4 subpel MC", offsetof(MpegEncContext, quarter_sample), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},
2552     {"divx_packed", "divx style packed b frames", offsetof(MpegEncContext, divx_packed), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},
2553     {NULL}
2554 };
2555
2556 static const AVClass mpeg4_class = {
2557     "MPEG4 Video Decoder",
2558     av_default_item_name,
2559     mpeg4_options,
2560     LIBAVUTIL_VERSION_INT,
2561 };
2562
2563 static const AVClass mpeg4_vdpau_class = {
2564     "MPEG4 Video VDPAU Decoder",
2565     av_default_item_name,
2566     mpeg4_options,
2567     LIBAVUTIL_VERSION_INT,
2568 };
2569
2570 AVCodec ff_mpeg4_decoder = {
2571     .name                  = "mpeg4",
2572     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
2573     .type                  = AVMEDIA_TYPE_VIDEO,
2574     .id                    = AV_CODEC_ID_MPEG4,
2575     .priv_data_size        = sizeof(MpegEncContext),
2576     .init                  = decode_init,
2577     .close                 = ff_h263_decode_end,
2578     .decode                = ff_h263_decode_frame,
2579     .capabilities          = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2580                              CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2581                              CODEC_CAP_FRAME_THREADS,
2582     .flush                 = ff_mpeg_flush,
2583     .max_lowres            = 3,
2584     .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
2585     .profiles              = NULL_IF_CONFIG_SMALL(mpeg4_video_profiles),
2586     .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context),
2587     .priv_class = &mpeg4_class,
2588 };
2589
2590
2591 #if CONFIG_MPEG4_VDPAU_DECODER
2592 AVCodec ff_mpeg4_vdpau_decoder = {
2593     .name           = "mpeg4_vdpau",
2594     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
2595     .type           = AVMEDIA_TYPE_VIDEO,
2596     .id             = AV_CODEC_ID_MPEG4,
2597     .priv_data_size = sizeof(MpegEncContext),
2598     .init           = decode_init,
2599     .close          = ff_h263_decode_end,
2600     .decode         = ff_h263_decode_frame,
2601     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2602                       CODEC_CAP_HWACCEL_VDPAU,
2603     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_MPEG4,
2604                                                   AV_PIX_FMT_NONE },
2605     .priv_class     = &mpeg4_vdpau_class,
2606 };
2607 #endif