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

   1 /*
   2  * H263/MPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard.
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * ac prediction encoding, b-frame support, error resilience, optimizations,
  22  * qpel decoding, gmc decoding, interlaced decoding,
  23  * by Michael Niedermayer <michaelni@gmx.at>
  24  */
  25
  26 //#define DEBUG
  27 #include "common.h"
  28 #include "dsputil.h"
  29 #include "avcodec.h"
  30 #include "mpegvideo.h"
  31 #include "h263data.h"
  32 #include "mpeg4data.h"
  33
  34 //#undef NDEBUG
  35 //#include <assert.h>
  36
  37 #if 1
  38 #define PRINT_MB_TYPE(a) {}
  39 #else
  40 #define PRINT_MB_TYPE(a) printf(a)
  41 #endif
  42
  43 #define INTRA_MCBPC_VLC_BITS 6
  44 #define INTER_MCBPC_VLC_BITS 6
  45 #define CBPY_VLC_BITS 6
  46 #define MV_VLC_BITS 9
  47 #define DC_VLC_BITS 9
  48 #define SPRITE_TRAJ_VLC_BITS 6
  49 #define MB_TYPE_B_VLC_BITS 4
  50 #define TEX_VLC_BITS 9
  51
  52 #ifdef CONFIG_ENCODERS
  53 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  54                               int n);
  55 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
  56 static void h263p_encode_umotion(MpegEncContext * s, int val);
  57 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  58                                int n, int dc, UINT8 *scan_table,
  59                                PutBitContext *dc_pb, PutBitContext *ac_pb);
  60 #endif
  61
  62 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
  63 static int h263p_decode_umotion(MpegEncContext * s, int pred);
  64 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  65                              int n, int coded);
  66 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
  67 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  68                               int n, int coded, int intra);
  69 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
  70 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
  71                               int dir);
  72 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
  73 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
  74
  75 extern UINT32 inverse[256];
  76
  77 static UINT16 uni_DCtab_lum  [512][2];
  78 static UINT16 uni_DCtab_chrom[512][2];
  79
  80 #ifdef CONFIG_ENCODERS
  81 static UINT16 (*mv_penalty)[MAX_MV*2+1]= NULL;
  82 static UINT8 fcode_tab[MAX_MV*2+1];
  83 static UINT8 umv_fcode_tab[MAX_MV*2+1];
  84
  85 static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
  86 static UINT8  uni_mpeg4_intra_rl_len [64*64*2*2];
  87 static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
  88 static UINT8  uni_mpeg4_inter_rl_len [64*64*2*2];
  89 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
  90 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
  91
  92 /* mpeg4
  93 inter
  94 max level: 24/6
  95 max run: 53/63
  96
  97 intra
  98 max level: 53/16
  99 max run: 29/41
 100 */
 101 #endif
 102
 103
 104 int h263_get_picture_format(int width, int height)
 105 {
 106     int format;
 107
 108     if (width == 128 && height == 96)
 109         format = 1;
 110     else if (width == 176 && height == 144)
 111         format = 2;
 112     else if (width == 352 && height == 288)
 113         format = 3;
 114     else if (width == 704 && height == 576)
 115         format = 4;
 116     else if (width == 1408 && height == 1152)
 117         format = 5;
 118     else
 119         format = 7;
 120     return format;
 121 }
 122
 123 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
 124 {
 125     int format;
 126
 127     align_put_bits(&s->pb);
 128
 129     /* Update the pointer to last GOB */
 130     s->ptr_lastgob = pbBufPtr(&s->pb);
 131     s->gob_number = 0;
 132
 133     put_bits(&s->pb, 22, 0x20); /* PSC */
 134     put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
 135                          s->frame_rate) & 0xff);
 136
 137     put_bits(&s->pb, 1, 1);     /* marker */
 138     put_bits(&s->pb, 1, 0);     /* h263 id */
 139     put_bits(&s->pb, 1, 0);     /* split screen off */
 140     put_bits(&s->pb, 1, 0);     /* camera  off */
 141     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
 142
 143     format = h263_get_picture_format(s->width, s->height);
 144     if (!s->h263_plus) {
 145         /* H.263v1 */
 146         put_bits(&s->pb, 3, format);
 147         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
 148         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
 149         of H.263v1 UMV implies to check the predicted MV after
 150         calculation of the current MB to see if we're on the limits */
 151         put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
 152         put_bits(&s->pb, 1, 0); /* SAC: off */
 153         put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
 154         put_bits(&s->pb, 1, 0); /* not PB frame */
 155         put_bits(&s->pb, 5, s->qscale);
 156         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 157     } else {
 158         /* H.263v2 */
 159         /* H.263 Plus PTYPE */
 160         put_bits(&s->pb, 3, 7);
 161         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
 162         if (format == 7)
 163             put_bits(&s->pb,3,6); /* Custom Source Format */
 164         else
 165             put_bits(&s->pb, 3, format);
 166
 167         put_bits(&s->pb,1,0); /* Custom PCF: off */
 168         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
 169         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
 170         put_bits(&s->pb,1,0); /* SAC: off */
 171         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
 172         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 173         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
 174         put_bits(&s->pb,1,0); /* Slice Structured: off */
 175         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 176         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 177         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
 178         put_bits(&s->pb,1,0); /* Modified Quantization: off */
 179         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 180         put_bits(&s->pb,3,0); /* Reserved */
 181
 182         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
 183
 184         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 185         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 186         if (s->pict_type == I_TYPE)
 187             s->no_rounding = 0;
 188         else
 189             s->no_rounding ^= 1;
 190         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 191         put_bits(&s->pb,2,0); /* Reserved */
 192         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 193
 194         /* This should be here if PLUSPTYPE */
 195         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 196
 197                 if (format == 7) {
 198             /* Custom Picture Format (CPFMT) */
 199
 200             if (s->aspect_ratio_info)
 201                 put_bits(&s->pb,4,s->aspect_ratio_info);
 202             else
 203                 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
 204             put_bits(&s->pb,9,(s->width >> 2) - 1);
 205             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 206             put_bits(&s->pb,9,(s->height >> 2));
 207             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
 208             {
 209                 put_bits(&s->pb, 8, s->aspected_width);
 210                 put_bits(&s->pb, 8, s->aspected_height);
 211             }
 212         }
 213
 214         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 215         if (s->umvplus)
 216             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 217         put_bits(&s->pb, 5, s->qscale);
 218     }
 219
 220     put_bits(&s->pb, 1, 0);     /* no PEI */
 221
 222     if(s->h263_aic){
 223          s->y_dc_scale_table=
 224          s->c_dc_scale_table= h263_aic_dc_scale_table;
 225     }else{
 226         s->y_dc_scale_table=
 227         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 228     }
 229 }
 230
 231 /**
 232  * Encodes a group of blocks header.
 233  */
 234 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
 235 {
 236            align_put_bits(&s->pb);
 237            flush_put_bits(&s->pb);
 238            /* Call the RTP callback to send the last GOB */
 239            if (s->rtp_callback) {
 240                int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 241                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
 242            }
 243            put_bits(&s->pb, 17, 1); /* GBSC */
 244            s->gob_number = mb_line / s->gob_index;
 245            put_bits(&s->pb, 5, s->gob_number); /* GN */
 246            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 247            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 248            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
 249     return 0;
 250 }
 251
 252 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
 253 {
 254     int score0=0, score1=0;
 255     int i, n;
 256
 257     for(n=0; n<6; n++){
 258         INT16 *ac_val, *ac_val1;
 259
 260         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 261         ac_val1= ac_val;
 262         if(dir[n]){
 263             const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
 264             /* top prediction */
 265             ac_val-= s->block_wrap[n]*16;
 266             if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
 267                 /* same qscale */
 268                 for(i=1; i<8; i++){
 269                     const int level= block[n][s->idct_permutation[i   ]];
 270                     score0+= ABS(level);
 271                     score1+= ABS(level - ac_val[i+8]);
 272                     ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
 273                     ac_val1[i+8]= level;
 274                 }
 275             }else{
 276                 /* different qscale, we must rescale */
 277                 for(i=1; i<8; i++){
 278                     const int level= block[n][s->idct_permutation[i   ]];
 279                     score0+= ABS(level);
 280                     score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale));
 281                     ac_val1[i  ]=    block[n][s->idct_permutation[i<<3]];
 282                     ac_val1[i+8]= level;
 283                 }
 284             }
 285         }else{
 286             const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
 287             /* left prediction */
 288             ac_val-= 16;
 289             if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
 290                 /* same qscale */
 291                 for(i=1; i<8; i++){
 292                     const int level= block[n][s->idct_permutation[i<<3]];
 293                     score0+= ABS(level);
 294                     score1+= ABS(level - ac_val[i]);
 295                     ac_val1[i  ]= level;
 296                     ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
 297                 }
 298             }else{
 299                 /* different qscale, we must rescale */
 300                 for(i=1; i<8; i++){
 301                     const int level= block[n][s->idct_permutation[i<<3]];
 302                     score0+= ABS(level);
 303                     score1+= ABS(level - ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale));
 304                     ac_val1[i  ]= level;
 305                     ac_val1[i+8]=    block[n][s->idct_permutation[i   ]];
 306                 }
 307             }
 308         }
 309     }
 310
 311     return score0 > score1 ? 1 : 0;
 312 }
 313
 314 /**
 315  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 316  */
 317 void ff_clean_h263_qscales(MpegEncContext *s){
 318     int i;
 319
 320     for(i=1; i<s->mb_num; i++){
 321         if(s->qscale_table[i] - s->qscale_table[i-1] >2)
 322             s->qscale_table[i]= s->qscale_table[i-1]+2;
 323     }
 324     for(i=s->mb_num-2; i>=0; i--){
 325         if(s->qscale_table[i] - s->qscale_table[i+1] >2)
 326             s->qscale_table[i]= s->qscale_table[i+1]+2;
 327     }
 328 }
 329
 330 /**
 331  * modify mb_type & qscale so that encoding is acually possible in mpeg4
 332  */
 333 void ff_clean_mpeg4_qscales(MpegEncContext *s){
 334     int i;
 335
 336     ff_clean_h263_qscales(s);
 337
 338     for(i=1; i<s->mb_num; i++){
 339         if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
 340             s->mb_type[i]&= ~MB_TYPE_INTER4V;
 341             s->mb_type[i]|= MB_TYPE_INTER;
 342         }
 343     }
 344
 345     if(s->pict_type== B_TYPE){
 346         int odd=0;
 347         /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
 348            for the actual adaptive quantization */
 349
 350         for(i=0; i<s->mb_num; i++){
 351             odd += s->qscale_table[i]&1;
 352         }
 353
 354         if(2*odd > s->mb_num) odd=1;
 355         else                  odd=0;
 356
 357         for(i=0; i<s->mb_num; i++){
 358             if((s->qscale_table[i]&1) != odd)
 359                 s->qscale_table[i]++;
 360             if(s->qscale_table[i] > 31)
 361                 s->qscale_table[i]= 31;
 362         }
 363
 364         for(i=1; i<s->mb_num; i++){
 365             if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
 366                 s->mb_type[i]&= ~MB_TYPE_DIRECT;
 367                 s->mb_type[i]|= MB_TYPE_BIDIR;
 368             }
 369         }
 370     }
 371 }
 372
 373 #ifdef CONFIG_ENCODERS
 374 void mpeg4_encode_mb(MpegEncContext * s,
 375                     DCTELEM block[6][64],
 376                     int motion_x, int motion_y)
 377 {
 378     int cbpc, cbpy, i, pred_x, pred_y;
 379     int bits;
 380     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
 381     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
 382     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
 383     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
 384     const int dquant_code[5]= {1,0,9,2,3};
 385
 386     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 387     if (!s->mb_intra) {
 388         /* compute cbp */
 389         int cbp = 0;
 390         for (i = 0; i < 6; i++) {
 391             if (s->block_last_index[i] >= 0)
 392                 cbp |= 1 << (5 - i);
 393         }
 394
 395         if(s->pict_type==B_TYPE){
 396             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
 397             int mb_type=  mb_type_table[s->mv_dir];
 398
 399             if(s->mb_x==0){
 400                 s->last_mv[0][0][0]=
 401                 s->last_mv[0][0][1]=
 402                 s->last_mv[1][0][0]=
 403                 s->last_mv[1][0][1]= 0;
 404             }
 405
 406             assert(s->dquant>=-2 && s->dquant<=2);
 407             assert((s->dquant&1)==0);
 408             assert(mb_type>=0);
 409
 410             /* nothing to do if this MB was skiped in the next P Frame */
 411             if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
 412                 s->skip_count++;
 413                 s->mv[0][0][0]=
 414                 s->mv[0][0][1]=
 415                 s->mv[1][0][0]=
 416                 s->mv[1][0][1]= 0;
 417                 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
 418                 s->qscale -= s->dquant;
 419                 return;
 420             }
 421
 422             if ((cbp | motion_x | motion_y | mb_type) ==0) {
 423                 /* direct MB with MV={0,0} */
 424                 assert(s->dquant==0);
 425
 426                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
 427
 428                 if(interleaved_stats){
 429                     s->misc_bits++;
 430                     s->last_bits++;
 431                 }
 432                 s->skip_count++;
 433                 return;
 434             }
 435             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
 436             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
 437             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
 438             if(cbp) put_bits(&s->pb, 6, cbp);
 439
 440             if(cbp && mb_type){
 441                 if(s->dquant)
 442                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
 443                 else
 444                     put_bits(&s->pb, 1, 0);
 445             }else
 446                 s->qscale -= s->dquant;
 447
 448             if(!s->progressive_sequence){
 449                 if(cbp)
 450                     put_bits(&s->pb, 1, s->interlaced_dct);
 451                 if(mb_type) // not diect mode
 452                     put_bits(&s->pb, 1, 0); // no interlaced ME yet
 453             }
 454
 455             if(interleaved_stats){
 456                 bits= get_bit_count(&s->pb);
 457                 s->misc_bits+= bits - s->last_bits;
 458                 s->last_bits=bits;
 459             }
 460
 461             switch(mb_type)
 462             {
 463             case 0: /* direct */
 464                 h263_encode_motion(s, motion_x, 1);
 465                 h263_encode_motion(s, motion_y, 1);
 466                 s->b_count++;
 467                 s->f_count++;
 468                 break;
 469             case 1: /* bidir */
 470                 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
 471                 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
 472                 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
 473                 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
 474                 s->last_mv[0][0][0]= s->mv[0][0][0];
 475                 s->last_mv[0][0][1]= s->mv[0][0][1];
 476                 s->last_mv[1][0][0]= s->mv[1][0][0];
 477                 s->last_mv[1][0][1]= s->mv[1][0][1];
 478                 s->b_count++;
 479                 s->f_count++;
 480                 break;
 481             case 2: /* backward */
 482                 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
 483                 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
 484                 s->last_mv[1][0][0]= motion_x;
 485                 s->last_mv[1][0][1]= motion_y;
 486                 s->b_count++;
 487                 break;
 488             case 3: /* forward */
 489                 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
 490                 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
 491                 s->last_mv[0][0][0]= motion_x;
 492                 s->last_mv[0][0][1]= motion_y;
 493                 s->f_count++;
 494                 break;
 495             default:
 496                 printf("unknown mb type\n");
 497                 return;
 498             }
 499
 500             if(interleaved_stats){
 501                 bits= get_bit_count(&s->pb);
 502                 s->mv_bits+= bits - s->last_bits;
 503                 s->last_bits=bits;
 504             }
 505
 506             /* encode each block */
 507             for (i = 0; i < 6; i++) {
 508                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
 509             }
 510
 511             if(interleaved_stats){
 512                 bits= get_bit_count(&s->pb);
 513                 s->p_tex_bits+= bits - s->last_bits;
 514                 s->last_bits=bits;
 515             }
 516         }else{ /* s->pict_type==B_TYPE */
 517             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
 518                 /* check if the B frames can skip it too, as we must skip it if we skip here
 519                    why didnt they just compress the skip-mb bits instead of reusing them ?! */
 520                 if(s->max_b_frames>0){
 521                     int i;
 522                     int x,y, offset;
 523                     uint8_t *p_pic;
 524
 525                     x= s->mb_x*16;
 526                     y= s->mb_y*16;
 527                     if(x+16 > s->width)  x= s->width-16;
 528                     if(y+16 > s->height) y= s->height-16;
 529
 530                     offset= x + y*s->linesize;
 531                     p_pic= s->new_picture[0] + offset;
 532
 533                     s->mb_skiped=1;
 534                     for(i=0; i<s->max_b_frames; i++){
 535                         uint8_t *b_pic;
 536                         int diff;
 537
 538                         if(s->coded_order[i+1].pict_type!=B_TYPE) break;
 539
 540                         b_pic= s->coded_order[i+1].picture[0] + offset;
 541                         diff= pix_abs16x16(p_pic, b_pic, s->linesize);
 542                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
 543                             s->mb_skiped=0;
 544                             break;
 545                         }
 546                     }
 547                 }else
 548                     s->mb_skiped=1;
 549
 550                 if(s->mb_skiped==1){
 551                     /* skip macroblock */
 552                     put_bits(&s->pb, 1, 1);
 553
 554                     if(interleaved_stats){
 555                         s->misc_bits++;
 556                         s->last_bits++;
 557                     }
 558                     s->skip_count++;
 559                     return;
 560                 }
 561             }
 562
 563             put_bits(&s->pb, 1, 0);     /* mb coded */
 564             if(s->mv_type==MV_TYPE_16X16){
 565                 cbpc = cbp & 3;
 566                 if(s->dquant) cbpc+= 8;
 567                 put_bits(&s->pb,
 568                         inter_MCBPC_bits[cbpc],
 569                         inter_MCBPC_code[cbpc]);
 570
 571                 cbpy = cbp >> 2;
 572                 cbpy ^= 0xf;
 573                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 574                 if(s->dquant)
 575                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
 576
 577                 if(!s->progressive_sequence){
 578                     if(cbp)
 579                         put_bits(pb2, 1, s->interlaced_dct);
 580                     put_bits(pb2, 1, 0); // no interlaced ME yet
 581                 }
 582
 583                 if(interleaved_stats){
 584                     bits= get_bit_count(&s->pb);
 585                     s->misc_bits+= bits - s->last_bits;
 586                     s->last_bits=bits;
 587                 }
 588
 589                 /* motion vectors: 16x16 mode */
 590                 h263_pred_motion(s, 0, &pred_x, &pred_y);
 591
 592                 h263_encode_motion(s, motion_x - pred_x, s->f_code);
 593                 h263_encode_motion(s, motion_y - pred_y, s->f_code);
 594             }else{
 595                 cbpc = (cbp & 3)+16;
 596                 put_bits(&s->pb,
 597                         inter_MCBPC_bits[cbpc],
 598                         inter_MCBPC_code[cbpc]);
 599                 cbpy = cbp >> 2;
 600                 cbpy ^= 0xf;
 601                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 602
 603                 if(!s->progressive_sequence){
 604                     if(cbp)
 605                         put_bits(pb2, 1, s->interlaced_dct);
 606                 }
 607
 608                 if(interleaved_stats){
 609                     bits= get_bit_count(&s->pb);
 610                     s->misc_bits+= bits - s->last_bits;
 611                     s->last_bits=bits;
 612                 }
 613
 614                 for(i=0; i<4; i++){
 615                     /* motion vectors: 8x8 mode*/
 616                     h263_pred_motion(s, i, &pred_x, &pred_y);
 617
 618                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
 619                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
 620                 }
 621             }
 622
 623             if(interleaved_stats){
 624                 bits= get_bit_count(&s->pb);
 625                 s->mv_bits+= bits - s->last_bits;
 626                 s->last_bits=bits;
 627             }
 628
 629             /* encode each block */
 630             for (i = 0; i < 6; i++) {
 631                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
 632             }
 633
 634             if(interleaved_stats){
 635                 bits= get_bit_count(&s->pb);
 636                 s->p_tex_bits+= bits - s->last_bits;
 637                 s->last_bits=bits;
 638             }
 639             s->f_count++;
 640         }
 641     } else {
 642         int cbp;
 643         int dc_diff[6];   //dc values with the dc prediction subtracted
 644         int dir[6];  //prediction direction
 645         int zigzag_last_index[6];
 646         UINT8 *scan_table[6];
 647
 648         for(i=0; i<6; i++){
 649             const int level= block[i][0];
 650             UINT16 *dc_ptr;
 651
 652             dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
 653             if (i < 4) {
 654                 *dc_ptr = level * s->y_dc_scale;
 655             } else {
 656                 *dc_ptr = level * s->c_dc_scale;
 657             }
 658         }
 659
 660         s->ac_pred= decide_ac_pred(s, block, dir);
 661
 662         if(s->ac_pred){
 663             for(i=0; i<6; i++){
 664                 UINT8 *st;
 665                 int last_index;
 666
 667                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
 668                 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
 669                 else           st = s->intra_h_scantable.permutated; /* top */
 670
 671                 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
 672                     if(block[i][st[last_index]]) break;
 673                 zigzag_last_index[i]= s->block_last_index[i];
 674                 s->block_last_index[i]= last_index;
 675                 scan_table[i]= st;
 676             }
 677         }else{
 678             for(i=0; i<6; i++)
 679                 scan_table[i]= s->intra_scantable.permutated;
 680         }
 681
 682         /* compute cbp */
 683         cbp = 0;
 684         for (i = 0; i < 6; i++) {
 685             if (s->block_last_index[i] >= 1)
 686                 cbp |= 1 << (5 - i);
 687         }
 688
 689         cbpc = cbp & 3;
 690         if (s->pict_type == I_TYPE) {
 691             if(s->dquant) cbpc+=4;
 692             put_bits(&s->pb,
 693                 intra_MCBPC_bits[cbpc],
 694                 intra_MCBPC_code[cbpc]);
 695         } else {
 696             if(s->dquant) cbpc+=8;
 697             put_bits(&s->pb, 1, 0);     /* mb coded */
 698             put_bits(&s->pb,
 699                 inter_MCBPC_bits[cbpc + 4],
 700                 inter_MCBPC_code[cbpc + 4]);
 701         }
 702         put_bits(pb2, 1, s->ac_pred);
 703         cbpy = cbp >> 2;
 704         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 705         if(s->dquant)
 706             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
 707
 708         if(!s->progressive_sequence){
 709             put_bits(dc_pb, 1, s->interlaced_dct);
 710         }
 711
 712         if(interleaved_stats){
 713             bits= get_bit_count(&s->pb);
 714             s->misc_bits+= bits - s->last_bits;
 715             s->last_bits=bits;
 716         }
 717
 718         /* encode each block */
 719         for (i = 0; i < 6; i++) {
 720             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
 721         }
 722
 723         if(interleaved_stats){
 724             bits= get_bit_count(&s->pb);
 725             s->i_tex_bits+= bits - s->last_bits;
 726             s->last_bits=bits;
 727         }
 728         s->i_count++;
 729
 730         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
 731         if(s->ac_pred){
 732             for(i=0; i<6; i++){
 733                 int j;
 734                 INT16 *ac_val;
 735
 736                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
 737
 738                 if(dir[i]){
 739                     for(j=1; j<8; j++)
 740                         block[i][s->idct_permutation[j   ]]= ac_val[j+8];
 741                 }else{
 742                     for(j=1; j<8; j++)
 743                         block[i][s->idct_permutation[j<<3]]= ac_val[j  ];
 744                 }
 745                 s->block_last_index[i]= zigzag_last_index[i];
 746             }
 747         }
 748     }
 749 }
 750
 751 void h263_encode_mb(MpegEncContext * s,
 752                     DCTELEM block[6][64],
 753                     int motion_x, int motion_y)
 754 {
 755     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 756     INT16 pred_dc;
 757     INT16 rec_intradc[6];
 758     UINT16 *dc_ptr[6];
 759     const int dquant_code[5]= {1,0,9,2,3};
 760
 761     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 762     if (!s->mb_intra) {
 763         /* compute cbp */
 764         cbp = 0;
 765         for (i = 0; i < 6; i++) {
 766             if (s->block_last_index[i] >= 0)
 767                 cbp |= 1 << (5 - i);
 768         }
 769         if ((cbp | motion_x | motion_y | s->dquant) == 0) {
 770             /* skip macroblock */
 771             put_bits(&s->pb, 1, 1);
 772             return;
 773         }
 774         put_bits(&s->pb, 1, 0); /* mb coded */
 775         cbpc = cbp & 3;
 776         if(s->dquant) cbpc+= 8;
 777         put_bits(&s->pb,
 778                     inter_MCBPC_bits[cbpc],
 779                     inter_MCBPC_code[cbpc]);
 780         cbpy = cbp >> 2;
 781         cbpy ^= 0xf;
 782         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 783         if(s->dquant)
 784             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 785
 786         /* motion vectors: 16x16 mode only now */
 787         h263_pred_motion(s, 0, &pred_x, &pred_y);
 788
 789         if (!s->umvplus) {
 790             h263_encode_motion(s, motion_x - pred_x, s->f_code);
 791             h263_encode_motion(s, motion_y - pred_y, s->f_code);
 792         }
 793         else {
 794             h263p_encode_umotion(s, motion_x - pred_x);
 795             h263p_encode_umotion(s, motion_y - pred_y);
 796             if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 797                 /* To prevent Start Code emulation */
 798                 put_bits(&s->pb,1,1);
 799         }
 800     } else {
 801         int li = s->h263_aic ? 0 : 1;
 802
 803         cbp = 0;
 804         for(i=0; i<6; i++) {
 805             /* Predict DC */
 806             if (s->h263_aic && s->mb_intra) {
 807                 INT16 level = block[i][0];
 808
 809                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
 810                 level -= pred_dc;
 811                 /* Quant */
 812                 if (level < 0)
 813                     level = (level + (s->qscale >> 1))/(s->y_dc_scale);
 814                 else
 815                     level = (level - (s->qscale >> 1))/(s->y_dc_scale);
 816
 817                 /* AIC can change CBP */
 818                 if (level == 0 && s->block_last_index[i] == 0)
 819                     s->block_last_index[i] = -1;
 820                 else if (level < -127)
 821                     level = -127;
 822                 else if (level > 127)
 823                     level = 127;
 824
 825                 block[i][0] = level;
 826                 /* Reconstruction */
 827                 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
 828                 /* Oddify */
 829                 rec_intradc[i] |= 1;
 830                 //if ((rec_intradc[i] % 2) == 0)
 831                 //    rec_intradc[i]++;
 832                 /* Clipping */
 833                 if (rec_intradc[i] < 0)
 834                     rec_intradc[i] = 0;
 835                 else if (rec_intradc[i] > 2047)
 836                     rec_intradc[i] = 2047;
 837
 838                 /* Update AC/DC tables */
 839                 *dc_ptr[i] = rec_intradc[i];
 840             }
 841             /* compute cbp */
 842             if (s->block_last_index[i] >= li)
 843                 cbp |= 1 << (5 - i);
 844         }
 845
 846         cbpc = cbp & 3;
 847         if (s->pict_type == I_TYPE) {
 848             if(s->dquant) cbpc+=4;
 849             put_bits(&s->pb,
 850                 intra_MCBPC_bits[cbpc],
 851                 intra_MCBPC_code[cbpc]);
 852         } else {
 853             if(s->dquant) cbpc+=8;
 854             put_bits(&s->pb, 1, 0);     /* mb coded */
 855             put_bits(&s->pb,
 856                 inter_MCBPC_bits[cbpc + 4],
 857                 inter_MCBPC_code[cbpc + 4]);
 858         }
 859         if (s->h263_aic) {
 860             /* XXX: currently, we do not try to use ac prediction */
 861             put_bits(&s->pb, 1, 0);     /* no AC prediction */
 862         }
 863         cbpy = cbp >> 2;
 864         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 865         if(s->dquant)
 866             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 867     }
 868
 869     for(i=0; i<6; i++) {
 870         /* encode each block */
 871         h263_encode_block(s, block[i], i);
 872
 873         /* Update INTRADC for decoding */
 874         if (s->h263_aic && s->mb_intra) {
 875             block[i][0] = rec_intradc[i];
 876
 877         }
 878     }
 879 }
 880 #endif
 881
 882 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
 883 {
 884     int x, y, wrap, a, c, pred_dc, scale;
 885     INT16 *dc_val, *ac_val;
 886
 887     /* find prediction */
 888     if (n < 4) {
 889         x = 2 * s->mb_x + 1 + (n & 1);
 890         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 891         wrap = s->mb_width * 2 + 2;
 892         dc_val = s->dc_val[0];
 893         ac_val = s->ac_val[0][0];
 894         scale = s->y_dc_scale;
 895     } else {
 896         x = s->mb_x + 1;
 897         y = s->mb_y + 1;
 898         wrap = s->mb_width + 2;
 899         dc_val = s->dc_val[n - 4 + 1];
 900         ac_val = s->ac_val[n - 4 + 1][0];
 901         scale = s->c_dc_scale;
 902     }
 903     /* B C
 904      * A X
 905      */
 906     a = dc_val[(x - 1) + (y) * wrap];
 907     c = dc_val[(x) + (y - 1) * wrap];
 908
 909     /* No prediction outside GOB boundary */
 910     if (s->first_slice_line && ((n < 2) || (n > 3)))
 911         c = 1024;
 912     pred_dc = 1024;
 913     /* just DC prediction */
 914     if (a != 1024 && c != 1024)
 915         pred_dc = (a + c) >> 1;
 916     else if (a != 1024)
 917         pred_dc = a;
 918     else
 919         pred_dc = c;
 920
 921     /* we assume pred is positive */
 922     //pred_dc = (pred_dc + (scale >> 1)) / scale;
 923     *dc_val_ptr = &dc_val[x + y * wrap];
 924     return pred_dc;
 925 }
 926
 927
 928 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
 929 {
 930     int x, y, wrap, a, c, pred_dc, scale, i;
 931     INT16 *dc_val, *ac_val, *ac_val1;
 932
 933     /* find prediction */
 934     if (n < 4) {
 935         x = 2 * s->mb_x + 1 + (n & 1);
 936         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 937         wrap = s->mb_width * 2 + 2;
 938         dc_val = s->dc_val[0];
 939         ac_val = s->ac_val[0][0];
 940         scale = s->y_dc_scale;
 941     } else {
 942         x = s->mb_x + 1;
 943         y = s->mb_y + 1;
 944         wrap = s->mb_width + 2;
 945         dc_val = s->dc_val[n - 4 + 1];
 946         ac_val = s->ac_val[n - 4 + 1][0];
 947         scale = s->c_dc_scale;
 948     }
 949
 950     ac_val += ((y) * wrap + (x)) * 16;
 951     ac_val1 = ac_val;
 952
 953     /* B C
 954      * A X
 955      */
 956     a = dc_val[(x - 1) + (y) * wrap];
 957     c = dc_val[(x) + (y - 1) * wrap];
 958
 959     /* No prediction outside GOB boundary */
 960     if (s->first_slice_line && ((n < 2) || (n > 3)))
 961         c = 1024;
 962     pred_dc = 1024;
 963     if (s->ac_pred) {
 964         if (s->h263_aic_dir) {
 965             /* left prediction */
 966             if (a != 1024) {
 967                 ac_val -= 16;
 968                 for(i=1;i<8;i++) {
 969                     block[s->idct_permutation[i<<3]] += ac_val[i];
 970                 }
 971                 pred_dc = a;
 972             }
 973         } else {
 974             /* top prediction */
 975             if (c != 1024) {
 976                 ac_val -= 16 * wrap;
 977                 for(i=1;i<8;i++) {
 978                     block[s->idct_permutation[i   ]] += ac_val[i + 8];
 979                 }
 980                 pred_dc = c;
 981             }
 982         }
 983     } else {
 984         /* just DC prediction */
 985         if (a != 1024 && c != 1024)
 986             pred_dc = (a + c) >> 1;
 987         else if (a != 1024)
 988             pred_dc = a;
 989         else
 990             pred_dc = c;
 991     }
 992
 993     /* we assume pred is positive */
 994     block[0]=block[0]*scale + pred_dc;
 995
 996     if (block[0] < 0)
 997         block[0] = 0;
 998     else if (!(block[0] & 1))
 999         block[0]++;
1000
1001     /* Update AC/DC tables */
1002     dc_val[(x) + (y) * wrap] = block[0];
1003
1004     /* left copy */
1005     for(i=1;i<8;i++)
1006         ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1007     /* top copy */
1008     for(i=1;i<8;i++)
1009         ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1010 }
1011
1012 INT16 *h263_pred_motion(MpegEncContext * s, int block,
1013                         int *px, int *py)
1014 {
1015     int xy, wrap;
1016     INT16 *A, *B, *C, *mot_val;
1017     static const int off[4]= {2, 1, 1, -1};
1018
1019     wrap = s->block_wrap[0];
1020     xy = s->block_index[block];
1021
1022     mot_val = s->motion_val[xy];
1023
1024     A = s->motion_val[xy - 1];
1025     /* special case for first (slice) line */
1026     if (s->first_slice_line && block<3) {
1027         // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1028         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1029         if(block==0){ //most common case
1030             if(s->mb_x  == s->resync_mb_x){ //rare
1031                 *px= *py = 0;
1032             }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1033                 C = s->motion_val[xy + off[block] - wrap];
1034                 if(s->mb_x==0){
1035                     *px = C[0];
1036                     *py = C[1];
1037                 }else{
1038                     *px = mid_pred(A[0], 0, C[0]);
1039                     *py = mid_pred(A[1], 0, C[1]);
1040                 }
1041             }else{
1042                 *px = A[0];
1043                 *py = A[1];
1044             }
1045         }else if(block==1){
1046             if(s->mb_x + 1 == s->resync_mb_x){ //rare
1047                 C = s->motion_val[xy + off[block] - wrap];
1048                 *px = mid_pred(A[0], 0, C[0]);
1049                 *py = mid_pred(A[1], 0, C[1]);
1050             }else{
1051                 *px = A[0];
1052                 *py = A[1];
1053             }
1054         }else{ /* block==2*/
1055             B = s->motion_val[xy - wrap];
1056             C = s->motion_val[xy + off[block] - wrap];
1057             if(s->mb_x == s->resync_mb_x) //rare
1058                 A[0]=A[1]=0;
1059
1060             *px = mid_pred(A[0], B[0], C[0]);
1061             *py = mid_pred(A[1], B[1], C[1]);
1062         }
1063     } else {
1064         B = s->motion_val[xy - wrap];
1065         C = s->motion_val[xy + off[block] - wrap];
1066         *px = mid_pred(A[0], B[0], C[0]);
1067         *py = mid_pred(A[1], B[1], C[1]);
1068     }
1069     return mot_val;
1070 }
1071
1072 #ifdef CONFIG_ENCODERS
1073 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1074 {
1075     int range, l, bit_size, sign, code, bits;
1076
1077     if (val == 0) {
1078         /* zero vector */
1079         code = 0;
1080         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1081     } else {
1082         bit_size = f_code - 1;
1083         range = 1 << bit_size;
1084         /* modulo encoding */
1085         l = range * 32;
1086 #if 1
1087         val+= l;
1088         val&= 2*l-1;
1089         val-= l;
1090         sign = val>>31;
1091         val= (val^sign)-sign;
1092         sign&=1;
1093 #else
1094         if (val < -l) {
1095             val += 2*l;
1096         } else if (val >= l) {
1097             val -= 2*l;
1098         }
1099
1100         assert(val>=-l && val<l);
1101
1102         if (val >= 0) {
1103             sign = 0;
1104         } else {
1105             val = -val;
1106             sign = 1;
1107         }
1108 #endif
1109         val--;
1110         code = (val >> bit_size) + 1;
1111         bits = val & (range - 1);
1112
1113         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1114         if (bit_size > 0) {
1115             put_bits(&s->pb, bit_size, bits);
1116         }
1117     }
1118
1119 }
1120
1121 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1122 static void h263p_encode_umotion(MpegEncContext * s, int val)
1123 {
1124     short sval = 0;
1125     short i = 0;
1126     short n_bits = 0;
1127     short temp_val;
1128     int code = 0;
1129     int tcode;
1130
1131     if ( val == 0)
1132         put_bits(&s->pb, 1, 1);
1133     else if (val == 1)
1134         put_bits(&s->pb, 3, 0);
1135     else if (val == -1)
1136         put_bits(&s->pb, 3, 2);
1137     else {
1138
1139         sval = ((val < 0) ? (short)(-val):(short)val);
1140         temp_val = sval;
1141
1142         while (temp_val != 0) {
1143             temp_val = temp_val >> 1;
1144             n_bits++;
1145         }
1146
1147         i = n_bits - 1;
1148         while (i > 0) {
1149             tcode = (sval & (1 << (i-1))) >> (i-1);
1150             tcode = (tcode << 1) | 1;
1151             code = (code << 2) | tcode;
1152             i--;
1153         }
1154         code = ((code << 1) | (val < 0)) << 1;
1155         put_bits(&s->pb, (2*n_bits)+1, code);
1156         //printf("\nVal = %d\tCode = %d", sval, code);
1157     }
1158 }
1159
1160 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1161 {
1162     int f_code;
1163     int mv;
1164
1165     if(mv_penalty==NULL)
1166         mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1167
1168     for(f_code=1; f_code<=MAX_FCODE; f_code++){
1169         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1170             int len;
1171
1172             if(mv==0) len= mvtab[0][1];
1173             else{
1174                 int val, bit_size, range, code;
1175
1176                 bit_size = s->f_code - 1;
1177                 range = 1 << bit_size;
1178
1179                 val=mv;
1180                 if (val < 0)
1181                     val = -val;
1182                 val--;
1183                 code = (val >> bit_size) + 1;
1184                 if(code<33){
1185                     len= mvtab[code][1] + 1 + bit_size;
1186                 }else{
1187                     len= mvtab[32][1] + 2 + bit_size;
1188                 }
1189             }
1190
1191             mv_penalty[f_code][mv+MAX_MV]= len;
1192         }
1193     }
1194
1195     for(f_code=MAX_FCODE; f_code>0; f_code--){
1196         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1197             fcode_tab[mv+MAX_MV]= f_code;
1198         }
1199     }
1200
1201     for(mv=0; mv<MAX_MV*2+1; mv++){
1202         umv_fcode_tab[mv]= 1;
1203     }
1204 }
1205 #endif
1206
1207 static void init_uni_dc_tab(void)
1208 {
1209     int level, uni_code, uni_len;
1210
1211     for(level=-256; level<256; level++){
1212         int size, v, l;
1213         /* find number of bits */
1214         size = 0;
1215         v = abs(level);
1216         while (v) {
1217             v >>= 1;
1218             size++;
1219         }
1220
1221         if (level < 0)
1222             l= (-level) ^ ((1 << size) - 1);
1223         else
1224             l= level;
1225
1226         /* luminance */
1227         uni_code= DCtab_lum[size][0];
1228         uni_len = DCtab_lum[size][1];
1229
1230         if (size > 0) {
1231             uni_code<<=size; uni_code|=l;
1232             uni_len+=size;
1233             if (size > 8){
1234                 uni_code<<=1; uni_code|=1;
1235                 uni_len++;
1236             }
1237         }
1238         uni_DCtab_lum[level+256][0]= uni_code;
1239         uni_DCtab_lum[level+256][1]= uni_len;
1240
1241         /* chrominance */
1242         uni_code= DCtab_chrom[size][0];
1243         uni_len = DCtab_chrom[size][1];
1244
1245         if (size > 0) {
1246             uni_code<<=size; uni_code|=l;
1247             uni_len+=size;
1248             if (size > 8){
1249                 uni_code<<=1; uni_code|=1;
1250                 uni_len++;
1251             }
1252         }
1253         uni_DCtab_chrom[level+256][0]= uni_code;
1254         uni_DCtab_chrom[level+256][1]= uni_len;
1255
1256     }
1257 }
1258
1259 #ifdef CONFIG_ENCODERS
1260 static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1261     int slevel, run, last;
1262
1263     assert(MAX_LEVEL >= 64);
1264     assert(MAX_RUN   >= 63);
1265
1266     for(slevel=-64; slevel<64; slevel++){
1267         if(slevel==0) continue;
1268         for(run=0; run<64; run++){
1269             for(last=0; last<=1; last++){
1270                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1271                 int level= slevel < 0 ? -slevel : slevel;
1272                 int sign= slevel < 0 ? 1 : 0;
1273                 int bits, len, code;
1274                 int level1, run1;
1275
1276                 len_tab[index]= 100;
1277
1278                 /* ESC0 */
1279                 code= get_rl_index(rl, last, run, level);
1280                 bits= rl->table_vlc[code][0];
1281                 len=  rl->table_vlc[code][1];
1282                 bits=bits*2+sign; len++;
1283
1284                 if(code!=rl->n && len < len_tab[index]){
1285                     bits_tab[index]= bits;
1286                     len_tab [index]= len;
1287                 }
1288 #if 1
1289                 /* ESC1 */
1290                 bits= rl->table_vlc[rl->n][0];
1291                 len=  rl->table_vlc[rl->n][1];
1292                 bits=bits*2;    len++; //esc1
1293                 level1= level - rl->max_level[last][run];
1294                 if(level1>0){
1295                     code= get_rl_index(rl, last, run, level1);
1296                     bits<<= rl->table_vlc[code][1];
1297                     len  += rl->table_vlc[code][1];
1298                     bits += rl->table_vlc[code][0];
1299                     bits=bits*2+sign; len++;
1300
1301                     if(code!=rl->n && len < len_tab[index]){
1302                         bits_tab[index]= bits;
1303                         len_tab [index]= len;
1304                     }
1305                 }
1306 #endif
1307 #if 1
1308                 /* ESC2 */
1309                 bits= rl->table_vlc[rl->n][0];
1310                 len=  rl->table_vlc[rl->n][1];
1311                 bits=bits*4+2;    len+=2; //esc2
1312                 run1 = run - rl->max_run[last][level] - 1;
1313                 if(run1>=0){
1314                     code= get_rl_index(rl, last, run1, level);
1315                     bits<<= rl->table_vlc[code][1];
1316                     len  += rl->table_vlc[code][1];
1317                     bits += rl->table_vlc[code][0];
1318                     bits=bits*2+sign; len++;
1319
1320                     if(code!=rl->n && len < len_tab[index]){
1321                         bits_tab[index]= bits;
1322                         len_tab [index]= len;
1323                     }
1324                 }
1325 #endif
1326                 /* ESC3 */
1327                 bits= rl->table_vlc[rl->n][0];
1328                 len = rl->table_vlc[rl->n][1];
1329                 bits=bits*4+3;    len+=2; //esc3
1330                 bits=bits*2+last; len++;
1331                 bits=bits*64+run; len+=6;
1332                 bits=bits*2+1;    len++;  //marker
1333                 bits=bits*4096+(slevel&0xfff); len+=12;
1334                 bits=bits*2+1;    len++;  //marker
1335
1336                 if(len < len_tab[index]){
1337                     bits_tab[index]= bits;
1338                     len_tab [index]= len;
1339                 }
1340             }
1341         }
1342     }
1343 }
1344
1345 void h263_encode_init(MpegEncContext *s)
1346 {
1347     static int done = 0;
1348
1349     if (!done) {
1350         done = 1;
1351
1352         init_uni_dc_tab();
1353
1354         init_rl(&rl_inter);
1355         init_rl(&rl_intra);
1356         init_rl(&rl_intra_aic);
1357
1358         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1359         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1360
1361         init_mv_penalty_and_fcode(s);
1362     }
1363     s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1364
1365     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1366     switch(s->codec_id){
1367     case CODEC_ID_MPEG4:
1368         s->fcode_tab= fcode_tab;
1369         s->min_qcoeff= -2048;
1370         s->max_qcoeff=  2047;
1371         break;
1372     case CODEC_ID_H263P:
1373         s->fcode_tab= umv_fcode_tab;
1374         s->min_qcoeff= -128;
1375         s->max_qcoeff=  127;
1376         break;
1377         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1378     default: //nothing needed default table allready set in mpegvideo.c
1379         s->min_qcoeff= -128;
1380         s->max_qcoeff=  127;
1381         s->y_dc_scale_table=
1382         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1383     }
1384
1385     if(s->mpeg_quant){
1386         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1387         s->inter_quant_bias= 0;
1388     }else{
1389         s->intra_quant_bias=0;
1390         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1391     }
1392 }
1393
1394 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1395 {
1396     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1397     RLTable *rl;
1398
1399     rl = &rl_inter;
1400     if (s->mb_intra && !s->h263_aic) {
1401         /* DC coef */
1402             level = block[0];
1403         /* 255 cannot be represented, so we clamp */
1404         if (level > 254) {
1405             level = 254;
1406             block[0] = 254;
1407         }
1408         /* 0 cannot be represented also */
1409         else if (!level) {
1410             level = 1;
1411             block[0] = 1;
1412         }
1413             if (level == 128)
1414                 put_bits(&s->pb, 8, 0xff);
1415             else
1416                 put_bits(&s->pb, 8, level & 0xff);
1417             i = 1;
1418     } else {
1419             i = 0;
1420             if (s->h263_aic && s->mb_intra)
1421                 rl = &rl_intra_aic;
1422     }
1423
1424     /* AC coefs */
1425     last_index = s->block_last_index[n];
1426     last_non_zero = i - 1;
1427     for (; i <= last_index; i++) {
1428         j = s->intra_scantable.permutated[i];
1429         level = block[j];
1430         if (level) {
1431             run = i - last_non_zero - 1;
1432             last = (i == last_index);
1433             sign = 0;
1434             slevel = level;
1435             if (level < 0) {
1436                 sign = 1;
1437                 level = -level;
1438             }
1439             code = get_rl_index(rl, last, run, level);
1440             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1441             if (code == rl->n) {
1442                 put_bits(&s->pb, 1, last);
1443                 put_bits(&s->pb, 6, run);
1444                 put_bits(&s->pb, 8, slevel & 0xff);
1445             } else {
1446                 put_bits(&s->pb, 1, sign);
1447             }
1448                 last_non_zero = i;
1449             }
1450     }
1451 }
1452 #endif
1453
1454 /***************************************************/
1455 /**
1456  * add mpeg4 stuffing bits (01...1)
1457  */
1458 void ff_mpeg4_stuffing(PutBitContext * pbc)
1459 {
1460     int length;
1461     put_bits(pbc, 1, 0);
1462     length= (-get_bit_count(pbc))&7;
1463     if(length) put_bits(pbc, length, (1<<length)-1);
1464 }
1465
1466 /* must be called before writing the header */
1467 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1468     int time_div, time_mod;
1469
1470     if(s->pict_type==I_TYPE){ //we will encode a vol header
1471         s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1472         if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1473
1474         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1475     }
1476
1477     if(s->avctx->pts)
1478         s->time= (s->avctx->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1479     else
1480         s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1481     time_div= s->time/s->time_increment_resolution;
1482     time_mod= s->time%s->time_increment_resolution;
1483
1484     if(s->pict_type==B_TYPE){
1485         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1486     }else{
1487         s->last_time_base= s->time_base;
1488         s->time_base= time_div;
1489         s->pp_time= s->time - s->last_non_b_time;
1490         s->last_non_b_time= s->time;
1491     }
1492 }
1493
1494 static void mpeg4_encode_vol_header(MpegEncContext * s)
1495 {
1496     int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1497     char buf[255];
1498
1499     s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1500
1501     put_bits(&s->pb, 16, 0);
1502     put_bits(&s->pb, 16, 0x100);        /* video obj */
1503     put_bits(&s->pb, 16, 0);
1504     put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1505
1506     put_bits(&s->pb, 1, 0);             /* random access vol */
1507     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
1508     put_bits(&s->pb, 1, 1);             /* is obj layer id= yes */
1509       put_bits(&s->pb, 4, vo_ver_id);   /* is obj layer ver id */
1510       put_bits(&s->pb, 3, 1);           /* is obj layer priority */
1511     if(s->aspect_ratio_info)
1512         put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1513     else
1514         put_bits(&s->pb, 4, 1);         /* aspect ratio info= sqare pixel */
1515     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1516     {
1517         put_bits(&s->pb, 8, s->aspected_width);
1518         put_bits(&s->pb, 8, s->aspected_height);
1519     }
1520
1521     if(s->low_delay){
1522         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
1523         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
1524         put_bits(&s->pb, 1, s->low_delay);
1525         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
1526     }else{
1527         put_bits(&s->pb, 1, 0);         /* vol control parameters= no */
1528     }
1529
1530     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
1531     put_bits(&s->pb, 1, 1);             /* marker bit */
1532
1533     put_bits(&s->pb, 16, s->time_increment_resolution);
1534     if (s->time_increment_bits < 1)
1535         s->time_increment_bits = 1;
1536     put_bits(&s->pb, 1, 1);             /* marker bit */
1537     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
1538     put_bits(&s->pb, 1, 1);             /* marker bit */
1539     put_bits(&s->pb, 13, s->width);     /* vol width */
1540     put_bits(&s->pb, 1, 1);             /* marker bit */
1541     put_bits(&s->pb, 13, s->height);    /* vol height */
1542     put_bits(&s->pb, 1, 1);             /* marker bit */
1543     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1544     put_bits(&s->pb, 1, 1);             /* obmc disable */
1545     if (vo_ver_id == 1) {
1546         put_bits(&s->pb, 1, s->vol_sprite_usage=0);             /* sprite enable */
1547     }else{ /* vo_ver_id == 2 */
1548         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
1549     }
1550
1551     s->quant_precision=5;
1552     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
1553     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1554     if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1555
1556     if (vo_ver_id != 1)
1557         put_bits(&s->pb, 1, s->quarter_sample=0);
1558     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
1559     s->resync_marker= s->rtp_mode;
1560     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1561     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1562     if(s->data_partitioning){
1563         put_bits(&s->pb, 1, 0);         /* no rvlc */
1564     }
1565
1566     if (vo_ver_id != 1){
1567         put_bits(&s->pb, 1, 0);         /* newpred */
1568         put_bits(&s->pb, 1, 0);         /* reduced res vop */
1569     }
1570     put_bits(&s->pb, 1, 0);             /* scalability */
1571
1572     ff_mpeg4_stuffing(&s->pb);
1573
1574     /* user data */
1575     if(!ff_bit_exact){
1576         put_bits(&s->pb, 16, 0);
1577         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
1578         sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1579         put_string(&s->pb, buf);
1580         ff_mpeg4_stuffing(&s->pb);
1581     }
1582 }
1583
1584 /* write mpeg4 VOP header */
1585 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1586 {
1587     int time_incr;
1588     int time_div, time_mod;
1589
1590     if(s->pict_type==I_TYPE){
1591         s->no_rounding=0;
1592         if(picture_number==0 || !s->strict_std_compliance)
1593             mpeg4_encode_vol_header(s);
1594     }
1595
1596     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1597
1598 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1599
1600     put_bits(&s->pb, 16, 0);            /* vop header */
1601     put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1602     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
1603
1604     time_div= s->time/s->time_increment_resolution;
1605     time_mod= s->time%s->time_increment_resolution;
1606     time_incr= time_div - s->last_time_base;
1607     while(time_incr--)
1608         put_bits(&s->pb, 1, 1);
1609
1610     put_bits(&s->pb, 1, 0);
1611
1612     put_bits(&s->pb, 1, 1);     /* marker */
1613     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1614     put_bits(&s->pb, 1, 1);     /* marker */
1615     put_bits(&s->pb, 1, 1);     /* vop coded */
1616     if (    s->pict_type == P_TYPE
1617         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1618         s->no_rounding ^= 1;
1619         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
1620     }
1621     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
1622     if(!s->progressive_sequence){
1623          put_bits(&s->pb, 1, s->top_field_first);
1624          put_bits(&s->pb, 1, s->alternate_scan);
1625     }
1626     //FIXME sprite stuff
1627
1628     put_bits(&s->pb, 5, s->qscale);
1629
1630     if (s->pict_type != I_TYPE)
1631         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1632     if (s->pict_type == B_TYPE)
1633         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1634     //    printf("****frame %d\n", picture_number);
1635
1636      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1637      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1638      s->h_edge_pos= s->width;
1639      s->v_edge_pos= s->height;
1640 }
1641
1642 /**
1643  * change qscale by given dquant and update qscale dependant variables.
1644  */
1645 static void change_qscale(MpegEncContext * s, int dquant)
1646 {
1647     s->qscale += dquant;
1648
1649     if (s->qscale < 1)
1650         s->qscale = 1;
1651     else if (s->qscale > 31)
1652         s->qscale = 31;
1653
1654     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1655     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1656 }
1657
1658 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1659 {
1660     int a, b, c, wrap, pred, scale;
1661     UINT16 *dc_val;
1662     int dummy;
1663
1664     /* find prediction */
1665     if (n < 4) {
1666         scale = s->y_dc_scale;
1667     } else {
1668         scale = s->c_dc_scale;
1669     }
1670     wrap= s->block_wrap[n];
1671     dc_val = s->dc_val[0] + s->block_index[n];
1672
1673     /* B C
1674      * A X
1675      */
1676     a = dc_val[ - 1];
1677     b = dc_val[ - 1 - wrap];
1678     c = dc_val[ - wrap];
1679
1680     /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1681     if(s->first_slice_line && n!=3){
1682         if(n!=2) b=c= 1024;
1683         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1684     }
1685     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1686         if(n==0 || n==4 || n==5)
1687             b=1024;
1688     }
1689
1690     if (abs(a - b) < abs(b - c)) {
1691         pred = c;
1692         *dir_ptr = 1; /* top */
1693     } else {
1694         pred = a;
1695         *dir_ptr = 0; /* left */
1696     }
1697     /* we assume pred is positive */
1698 #ifdef ARCH_X86
1699         asm volatile (
1700                 "xorl %%edx, %%edx      \n\t"
1701                 "mul %%ecx              \n\t"
1702                 : "=d" (pred), "=a"(dummy)
1703                 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1704         );
1705 #else
1706     pred = (pred + (scale >> 1)) / scale;
1707 #endif
1708
1709     /* prepare address for prediction update */
1710     *dc_val_ptr = &dc_val[0];
1711
1712     return pred;
1713 }
1714
1715 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1716                    int dir)
1717 {
1718     int i;
1719     INT16 *ac_val, *ac_val1;
1720
1721     /* find prediction */
1722     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1723     ac_val1 = ac_val;
1724     if (s->ac_pred) {
1725         if (dir == 0) {
1726             const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1727             /* left prediction */
1728             ac_val -= 16;
1729
1730             if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1731                 /* same qscale */
1732                 for(i=1;i<8;i++) {
1733                     block[s->idct_permutation[i<<3]] += ac_val[i];
1734                 }
1735             }else{
1736                 /* different qscale, we must rescale */
1737                 for(i=1;i<8;i++) {
1738                     block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1739                 }
1740             }
1741         } else {
1742             const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1743             /* top prediction */
1744             ac_val -= 16 * s->block_wrap[n];
1745
1746             if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1747                 /* same qscale */
1748                 for(i=1;i<8;i++) {
1749                     block[s->idct_permutation[i]] += ac_val[i + 8];
1750                 }
1751             }else{
1752                 /* different qscale, we must rescale */
1753                 for(i=1;i<8;i++) {
1754                     block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1755                 }
1756             }
1757         }
1758     }
1759     /* left copy */
1760     for(i=1;i<8;i++)
1761         ac_val1[i    ] = block[s->idct_permutation[i<<3]];
1762
1763     /* top copy */
1764     for(i=1;i<8;i++)
1765         ac_val1[8 + i] = block[s->idct_permutation[i   ]];
1766
1767 }
1768
1769 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1770                               int dir)
1771 {
1772     int i;
1773     INT16 *ac_val;
1774
1775     /* find prediction */
1776     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1777
1778     if (dir == 0) {
1779         const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1780         /* left prediction */
1781         ac_val -= 16;
1782         if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1783             /* same qscale */
1784             for(i=1;i<8;i++) {
1785                 block[s->idct_permutation[i<<3]] -= ac_val[i];
1786             }
1787         }else{
1788             /* different qscale, we must rescale */
1789             for(i=1;i<8;i++) {
1790                 block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1791             }
1792         }
1793     } else {
1794         const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1795         /* top prediction */
1796         ac_val -= 16 * s->block_wrap[n];
1797         if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1798             /* same qscale */
1799             for(i=1;i<8;i++) {
1800                 block[s->idct_permutation[i]] -= ac_val[i + 8];
1801             }
1802         }else{
1803             /* different qscale, we must rescale */
1804             for(i=1;i<8;i++) {
1805                 block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1806             }
1807         }
1808     }
1809 }
1810
1811 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1812 {
1813 #if 1
1814 //    if(level<-255 || level>255) printf("dc overflow\n");
1815     level+=256;
1816     if (n < 4) {
1817         /* luminance */
1818         put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1819     } else {
1820         /* chrominance */
1821         put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1822     }
1823 #else
1824     int size, v;
1825     /* find number of bits */
1826     size = 0;
1827     v = abs(level);
1828     while (v) {
1829         v >>= 1;
1830         size++;
1831     }
1832
1833     if (n < 4) {
1834         /* luminance */
1835         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1836     } else {
1837         /* chrominance */
1838         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1839     }
1840
1841     /* encode remaining bits */
1842     if (size > 0) {
1843         if (level < 0)
1844             level = (-level) ^ ((1 << size) - 1);
1845         put_bits(&s->pb, size, level);
1846         if (size > 8)
1847             put_bits(&s->pb, 1, 1);
1848     }
1849 #endif
1850 }
1851 #ifdef CONFIG_ENCODERS
1852 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1853                                UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1854 {
1855     int i, last_non_zero;
1856 #if 0 //variables for the outcommented version
1857     int code, sign, last;
1858 #endif
1859     const RLTable *rl;
1860     UINT32 *bits_tab;
1861     UINT8 *len_tab;
1862     const int last_index = s->block_last_index[n];
1863
1864     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
1865         /* mpeg4 based DC predictor */
1866         mpeg4_encode_dc(dc_pb, intra_dc, n);
1867         if(last_index<1) return;
1868         i = 1;
1869         rl = &rl_intra;
1870         bits_tab= uni_mpeg4_intra_rl_bits;
1871         len_tab = uni_mpeg4_intra_rl_len;
1872     } else {
1873         if(last_index<0) return;
1874         i = 0;
1875         rl = &rl_inter;
1876         bits_tab= uni_mpeg4_inter_rl_bits;
1877         len_tab = uni_mpeg4_inter_rl_len;
1878     }
1879
1880     /* AC coefs */
1881     last_non_zero = i - 1;
1882 #if 1
1883     for (; i < last_index; i++) {
1884         int level = block[ scan_table[i] ];
1885         if (level) {
1886             int run = i - last_non_zero - 1;
1887             level+=64;
1888             if((level&(~127)) == 0){
1889                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
1890                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
1891             }else{ //ESC3
1892                 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
1893             }
1894             last_non_zero = i;
1895         }
1896     }
1897     /*if(i<=last_index)*/{
1898         int level = block[ scan_table[i] ];
1899         int run = i - last_non_zero - 1;
1900         level+=64;
1901         if((level&(~127)) == 0){
1902             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
1903             put_bits(ac_pb, len_tab[index], bits_tab[index]);
1904         }else{ //ESC3
1905             put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
1906         }
1907     }
1908 #else
1909     for (; i <= last_index; i++) {
1910         const int slevel = block[ scan_table[i] ];
1911         if (slevel) {
1912             int level;
1913             int run = i - last_non_zero - 1;
1914             last = (i == last_index);
1915             sign = 0;
1916             level = slevel;
1917             if (level < 0) {
1918                 sign = 1;
1919                 level = -level;
1920             }
1921             code = get_rl_index(rl, last, run, level);
1922             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1923             if (code == rl->n) {
1924                 int level1, run1;
1925                 level1 = level - rl->max_level[last][run];
1926                 if (level1 < 1)
1927                     goto esc2;
1928                 code = get_rl_index(rl, last, run, level1);
1929                 if (code == rl->n) {
1930                 esc2:
1931                     put_bits(ac_pb, 1, 1);
1932                     if (level > MAX_LEVEL)
1933                         goto esc3;
1934                     run1 = run - rl->max_run[last][level] - 1;
1935                     if (run1 < 0)
1936                         goto esc3;
1937                     code = get_rl_index(rl, last, run1, level);
1938                     if (code == rl->n) {
1939                     esc3:
1940                         /* third escape */
1941                         put_bits(ac_pb, 1, 1);
1942                         put_bits(ac_pb, 1, last);
1943                         put_bits(ac_pb, 6, run);
1944                         put_bits(ac_pb, 1, 1);
1945                         put_bits(ac_pb, 12, slevel & 0xfff);
1946                         put_bits(ac_pb, 1, 1);
1947                     } else {
1948                         /* second escape */
1949                         put_bits(ac_pb, 1, 0);
1950                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1951                         put_bits(ac_pb, 1, sign);
1952                     }
1953                 } else {
1954                     /* first escape */
1955                     put_bits(ac_pb, 1, 0);
1956                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1957                     put_bits(ac_pb, 1, sign);
1958                 }
1959             } else {
1960                 put_bits(ac_pb, 1, sign);
1961             }
1962             last_non_zero = i;
1963         }
1964     }
1965 #endif
1966 }
1967 #endif
1968
1969
1970 /***********************************************/
1971 /* decoding */
1972
1973 static VLC intra_MCBPC_vlc;
1974 static VLC inter_MCBPC_vlc;
1975 static VLC cbpy_vlc;
1976 static VLC mv_vlc;
1977 static VLC dc_lum, dc_chrom;
1978 static VLC sprite_trajectory;
1979 static VLC mb_type_b_vlc;
1980
1981 void init_rl(RLTable *rl)
1982 {
1983     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1984     UINT8 index_run[MAX_RUN+1];
1985     int last, run, level, start, end, i;
1986
1987     /* compute max_level[], max_run[] and index_run[] */
1988     for(last=0;last<2;last++) {
1989         if (last == 0) {
1990             start = 0;
1991             end = rl->last;
1992         } else {
1993             start = rl->last;
1994             end = rl->n;
1995         }
1996
1997         memset(max_level, 0, MAX_RUN + 1);
1998         memset(max_run, 0, MAX_LEVEL + 1);
1999         memset(index_run, rl->n, MAX_RUN + 1);
2000         for(i=start;i<end;i++) {
2001             run = rl->table_run[i];
2002             level = rl->table_level[i];
2003             if (index_run[run] == rl->n)
2004                 index_run[run] = i;
2005             if (level > max_level[run])
2006                 max_level[run] = level;
2007             if (run > max_run[level])
2008                 max_run[level] = run;
2009         }
2010         rl->max_level[last] = av_malloc(MAX_RUN + 1);
2011         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
2012         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
2013         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
2014         rl->index_run[last] = av_malloc(MAX_RUN + 1);
2015         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
2016     }
2017 }
2018
2019 void init_vlc_rl(RLTable *rl)
2020 {
2021     int i, q;
2022
2023     init_vlc(&rl->vlc, 9, rl->n + 1,
2024              &rl->table_vlc[0][1], 4, 2,
2025              &rl->table_vlc[0][0], 4, 2);
2026
2027
2028     for(q=0; q<32; q++){
2029         int qmul= q*2;
2030         int qadd= (q-1)|1;
2031
2032         if(q==0){
2033             qmul=1;
2034             qadd=0;
2035         }
2036
2037         rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2038         for(i=0; i<rl->vlc.table_size; i++){
2039             int code= rl->vlc.table[i][0];
2040             int len = rl->vlc.table[i][1];
2041             int level, run;
2042
2043             if(len==0){ // illegal code
2044                 run= 66;
2045                 level= MAX_LEVEL;
2046             }else if(len<0){ //more bits needed
2047                 run= 0;
2048                 level= code;
2049             }else{
2050                 if(code==rl->n){ //esc
2051                     run= 66;
2052                     level= 0;
2053                 }else{
2054                     run=   rl->table_run  [code] + 1;
2055                     level= rl->table_level[code] * qmul + qadd;
2056                     if(code >= rl->last) run+=192;
2057                 }
2058             }
2059             rl->rl_vlc[q][i].len= len;
2060             rl->rl_vlc[q][i].level= level;
2061             rl->rl_vlc[q][i].run= run;
2062         }
2063     }
2064 }
2065
2066 /* init vlcs */
2067
2068 /* XXX: find a better solution to handle static init */
2069 void h263_decode_init_vlc(MpegEncContext *s)
2070 {
2071     static int done = 0;
2072
2073     if (!done) {
2074         done = 1;
2075
2076         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
2077                  intra_MCBPC_bits, 1, 1,
2078                  intra_MCBPC_code, 1, 1);
2079         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
2080                  inter_MCBPC_bits, 1, 1,
2081                  inter_MCBPC_code, 1, 1);
2082         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2083                  &cbpy_tab[0][1], 2, 1,
2084                  &cbpy_tab[0][0], 2, 1);
2085         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2086                  &mvtab[0][1], 2, 1,
2087                  &mvtab[0][0], 2, 1);
2088         init_rl(&rl_inter);
2089         init_rl(&rl_intra);
2090         init_rl(&rl_intra_aic);
2091         init_vlc_rl(&rl_inter);
2092         init_vlc_rl(&rl_intra);
2093         init_vlc_rl(&rl_intra_aic);
2094         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2095                  &DCtab_lum[0][1], 2, 1,
2096                  &DCtab_lum[0][0], 2, 1);
2097         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2098                  &DCtab_chrom[0][1], 2, 1,
2099                  &DCtab_chrom[0][0], 2, 1);
2100         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2101                  &sprite_trajectory_tab[0][1], 4, 2,
2102                  &sprite_trajectory_tab[0][0], 4, 2);
2103         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2104                  &mb_type_b_tab[0][1], 2, 1,
2105                  &mb_type_b_tab[0][0], 2, 1);
2106     }
2107 }
2108
2109 /**
2110  * Get the GOB height based on picture height.
2111  */
2112 int ff_h263_get_gob_height(MpegEncContext *s){
2113     if (s->height <= 400)
2114         return 1;
2115     else if (s->height <= 800)
2116         return  2;
2117     else
2118         return 4;
2119 }
2120
2121 /**
2122  * decodes the group of blocks header.
2123  * @return <0 if an error occured
2124  */
2125 static int h263_decode_gob_header(MpegEncContext *s)
2126 {
2127     unsigned int val, gfid;
2128     int left;
2129
2130     /* Check for GOB Start Code */
2131     val = show_bits(&s->gb, 16);
2132     if(val)
2133         return -1;
2134
2135         /* We have a GBSC probably with GSTUFF */
2136     skip_bits(&s->gb, 16); /* Drop the zeros */
2137     left= s->gb.size*8 - get_bits_count(&s->gb);
2138     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2139     for(;left>13; left--){
2140         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2141     }
2142     if(left<=13)
2143         return -1;
2144
2145 #ifdef DEBUG
2146     fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2147 #endif
2148     s->gob_number = get_bits(&s->gb, 5); /* GN */
2149     gfid = get_bits(&s->gb, 2); /* GFID */
2150     s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2151     if(s->qscale==0)
2152         return -1;
2153     s->mb_x= 0;
2154     s->mb_y= s->gob_index* s->gob_number;
2155 #ifdef DEBUG
2156     fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2157 #endif
2158     return 0;
2159 }
2160
2161 static inline void memsetw(short *tab, int val, int n)
2162 {
2163     int i;
2164     for(i=0;i<n;i++)
2165         tab[i] = val;
2166 }
2167
2168 void ff_mpeg4_init_partitions(MpegEncContext *s)
2169 {
2170     init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2171     init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2172 }
2173
2174 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2175 {
2176     const int pb2_len   = get_bit_count(&s->pb2   );
2177     const int tex_pb_len= get_bit_count(&s->tex_pb);
2178     const int bits= get_bit_count(&s->pb);
2179
2180     if(s->pict_type==I_TYPE){
2181         put_bits(&s->pb, 19, DC_MARKER);
2182         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2183         s->i_tex_bits+= tex_pb_len;
2184     }else{
2185         put_bits(&s->pb, 17, MOTION_MARKER);
2186         s->misc_bits+=17 + pb2_len;
2187         s->mv_bits+= bits - s->last_bits;
2188         s->p_tex_bits+= tex_pb_len;
2189     }
2190
2191     flush_put_bits(&s->pb2);
2192     flush_put_bits(&s->tex_pb);
2193
2194     ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2195     ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2196     s->last_bits= get_bit_count(&s->pb);
2197 }
2198
2199 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2200     switch(s->pict_type){
2201         case I_TYPE:
2202             return 16;
2203         case P_TYPE:
2204         case S_TYPE:
2205             return s->f_code+15;
2206         case B_TYPE:
2207             return MAX(MAX(s->f_code, s->b_code)+15, 17);
2208         default:
2209             return -1;
2210     }
2211 }
2212
2213 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2214 {
2215     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2216
2217     ff_mpeg4_stuffing(&s->pb);
2218     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2219     put_bits(&s->pb, 1, 1);
2220
2221     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2222     put_bits(&s->pb, s->quant_precision, s->qscale);
2223     put_bits(&s->pb, 1, 0); /* no HEC */
2224 }
2225
2226 /**
2227  * check if the next stuff is a resync marker or the end.
2228  * @return 0 if not
2229  */
2230 static inline int mpeg4_is_resync(MpegEncContext *s){
2231     const int bits_count= get_bits_count(&s->gb);
2232
2233     if(s->workaround_bugs&FF_BUG_NO_PADDING){
2234         return 0;
2235     }
2236
2237     if(bits_count + 8 >= s->gb.size*8){
2238         int v= show_bits(&s->gb, 8);
2239         v|= 0x7F >> (7-(bits_count&7));
2240
2241         if(v==0x7F)
2242             return 1;
2243     }else{
2244         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2245             int len;
2246             GetBitContext gb= s->gb;
2247
2248             skip_bits(&s->gb, 1);
2249             align_get_bits(&s->gb);
2250
2251             for(len=0; len<32; len++){
2252                 if(get_bits1(&s->gb)) break;
2253             }
2254
2255             s->gb= gb;
2256
2257             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2258                 return 1;
2259         }
2260     }
2261     return 0;
2262 }
2263
2264 /**
2265  * decodes the next video packet.
2266  * @return <0 if something went wrong
2267  */
2268 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2269 {
2270     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2271     int header_extension=0, mb_num, len;
2272
2273     /* is there enough space left for a video packet + header */
2274     if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
2275
2276     for(len=0; len<32; len++){
2277         if(get_bits1(&s->gb)) break;
2278     }
2279
2280     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2281         printf("marker does not match f_code\n");
2282         return -1;
2283     }
2284
2285     if(s->shape != RECT_SHAPE){
2286         header_extension= get_bits1(&s->gb);
2287         //FIXME more stuff here
2288     }
2289
2290     mb_num= get_bits(&s->gb, mb_num_bits);
2291     if(mb_num>=s->mb_num){
2292         fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2293         return -1;
2294     }
2295     s->mb_x= mb_num % s->mb_width;
2296     s->mb_y= mb_num / s->mb_width;
2297
2298     if(s->shape != BIN_ONLY_SHAPE){
2299         int qscale= get_bits(&s->gb, s->quant_precision);
2300         if(qscale)
2301             s->qscale= qscale;
2302     }
2303
2304     if(s->shape == RECT_SHAPE){
2305         header_extension= get_bits1(&s->gb);
2306     }
2307     if(header_extension){
2308         int time_increment;
2309         int time_incr=0;
2310
2311         while (get_bits1(&s->gb) != 0)
2312             time_incr++;
2313
2314         check_marker(&s->gb, "before time_increment in video packed header");
2315         time_increment= get_bits(&s->gb, s->time_increment_bits);
2316         check_marker(&s->gb, "before vop_coding_type in video packed header");
2317
2318         skip_bits(&s->gb, 2); /* vop coding type */
2319         //FIXME not rect stuff here
2320
2321         if(s->shape != BIN_ONLY_SHAPE){
2322             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2323 //FIXME dont just ignore everything
2324             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2325                 mpeg4_decode_sprite_trajectory(s);
2326                 fprintf(stderr, "untested\n");
2327             }
2328
2329             //FIXME reduced res stuff here
2330
2331             if (s->pict_type != I_TYPE) {
2332                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
2333                 if(f_code==0){
2334                     printf("Error, video packet header damaged (f_code=0)\n");
2335                 }
2336             }
2337             if (s->pict_type == B_TYPE) {
2338                 int b_code = get_bits(&s->gb, 3);
2339                 if(b_code==0){
2340                     printf("Error, video packet header damaged (b_code=0)\n");
2341                 }
2342             }
2343         }
2344     }
2345     //FIXME new-pred stuff
2346
2347 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
2348
2349     return 0;
2350 }
2351
2352 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2353 {
2354     int c_wrap, c_xy, l_wrap, l_xy;
2355
2356     l_wrap= s->block_wrap[0];
2357     l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2358     c_wrap= s->block_wrap[4];
2359     c_xy= s->mb_y*c_wrap + s->mb_x;
2360
2361 #if 0
2362     /* clean DC */
2363     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2364     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2365     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2366 #endif
2367
2368     /* clean AC */
2369     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2370     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2371     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2372
2373     /* clean MV */
2374     // we cant clear the MVs as they might be needed by a b frame
2375 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2376 //    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2377     s->last_mv[0][0][0]=
2378     s->last_mv[0][0][1]=
2379     s->last_mv[1][0][0]=
2380     s->last_mv[1][0][1]= 0;
2381 }
2382
2383 /**
2384  * decodes the group of blocks / video packet header.
2385  * @return <0 if no resync found
2386  */
2387 int ff_h263_resync(MpegEncContext *s){
2388     int left, ret;
2389
2390     if(s->codec_id==CODEC_ID_MPEG4)
2391         skip_bits1(&s->gb);
2392
2393     align_get_bits(&s->gb);
2394
2395     if(show_bits(&s->gb, 16)==0){
2396         if(s->codec_id==CODEC_ID_MPEG4)
2397             ret= mpeg4_decode_video_packet_header(s);
2398         else
2399             ret= h263_decode_gob_header(s);
2400         if(ret>=0)
2401             return 0;
2402     }
2403     //ok, its not where its supposed to be ...
2404     s->gb= s->last_resync_gb;
2405     align_get_bits(&s->gb);
2406     left= s->gb.size*8 - get_bits_count(&s->gb);
2407
2408     for(;left>16+1+5+5; left-=8){
2409         if(show_bits(&s->gb, 16)==0){
2410             GetBitContext bak= s->gb;
2411
2412             if(s->codec_id==CODEC_ID_MPEG4)
2413                 ret= mpeg4_decode_video_packet_header(s);
2414             else
2415                 ret= h263_decode_gob_header(s);
2416             if(ret>=0)
2417                 return 0;
2418
2419             s->gb= bak;
2420         }
2421         skip_bits(&s->gb, 8);
2422     }
2423
2424     return -1;
2425 }
2426
2427 /**
2428  * @param n either 0 for the x component or 1 for y
2429  * @returns the average MV for a GMC MB
2430  */
2431 static inline int get_amv(MpegEncContext *s, int n){
2432     int x, y, mb_v, sum, dx, dy, shift;
2433     int len = 1 << (s->f_code + 4);
2434     const int a= s->sprite_warping_accuracy;
2435
2436     if(s->real_sprite_warping_points==1){
2437         if(s->divx_version==500 && s->divx_build==413)
2438             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2439         else
2440             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2441     }else{
2442         dx= s->sprite_delta[n][0];
2443         dy= s->sprite_delta[n][1];
2444         shift= s->sprite_shift[0];
2445         if(n) dy -= 1<<(shift + a + 1);
2446         else  dx -= 1<<(shift + a + 1);
2447         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2448
2449         sum=0;
2450         for(y=0; y<16; y++){
2451             int v;
2452
2453             v= mb_v + dy*y;
2454             //XXX FIXME optimize
2455             for(x=0; x<16; x++){
2456                 sum+= v>>shift;
2457                 v+= dx;
2458             }
2459         }
2460         sum /= 256;
2461         sum= RSHIFT(sum<<s->quarter_sample, a);
2462     }
2463
2464     if      (sum < -len) sum= -len;
2465     else if (sum >= len) sum= len-1;
2466
2467     return sum;
2468 }
2469
2470 /**
2471  * decodes first partition.
2472  * @return number of MBs decoded or <0 if an error occured
2473  */
2474 static int mpeg4_decode_partition_a(MpegEncContext *s){
2475     int mb_num;
2476     static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2477
2478     /* decode first partition */
2479     mb_num=0;
2480     s->first_slice_line=1;
2481     for(; s->mb_y<s->mb_height; s->mb_y++){
2482         ff_init_block_index(s);
2483         for(; s->mb_x<s->mb_width; s->mb_x++){
2484             const int xy= s->mb_x + s->mb_y*s->mb_width;
2485             int cbpc;
2486             int dir=0;
2487
2488             mb_num++;
2489             ff_update_block_index(s);
2490             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2491                 s->first_slice_line=0;
2492
2493             if(s->mb_x==0) PRINT_MB_TYPE("\n");
2494
2495             if(s->pict_type==I_TYPE){
2496                 int i;
2497
2498                 if(show_bits(&s->gb, 19)==DC_MARKER){
2499                     return mb_num-1;
2500                 }
2501
2502                 PRINT_MB_TYPE("I");
2503                 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2504                 if (cbpc < 0){
2505
2506                     fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2507                     return -1;
2508                 }
2509                 s->cbp_table[xy]= cbpc & 3;
2510                 s->mb_type[xy]= MB_TYPE_INTRA;
2511                 s->mb_intra = 1;
2512
2513                 if(cbpc & 4) {
2514                     change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2515                 }
2516                 s->qscale_table[xy]= s->qscale;
2517
2518                 s->mbintra_table[xy]= 1;
2519                 for(i=0; i<6; i++){
2520                     int dc_pred_dir;
2521                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2522                     if(dc < 0){
2523                         fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2524                         return -1;
2525                     }
2526                     dir<<=1;
2527                     if(dc_pred_dir) dir|=1;
2528                 }
2529                 s->pred_dir_table[xy]= dir;
2530
2531                 s->error_status_table[xy]= AC_ERROR;
2532             }else{ /* P/S_TYPE */
2533                 int mx, my, pred_x, pred_y, bits;
2534                 INT16 * const mot_val= s->motion_val[s->block_index[0]];
2535                 const int stride= s->block_wrap[0]*2;
2536
2537                 bits= show_bits(&s->gb, 17);
2538                 if(bits==MOTION_MARKER){
2539                     return mb_num-1;
2540                 }
2541                 skip_bits1(&s->gb);
2542                 if(bits&0x10000){
2543                     /* skip mb */
2544                     s->mb_type[xy]= MB_TYPE_SKIPED;
2545                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2546                         PRINT_MB_TYPE("G");
2547                         mx= get_amv(s, 0);
2548                         my= get_amv(s, 1);
2549                     }else{
2550                         PRINT_MB_TYPE("S");
2551                         mx=my=0;
2552                     }
2553                     mot_val[0       ]= mot_val[2       ]=
2554                     mot_val[0+stride]= mot_val[2+stride]= mx;
2555                     mot_val[1       ]= mot_val[3       ]=
2556                     mot_val[1+stride]= mot_val[3+stride]= my;
2557
2558                     if(s->mbintra_table[xy])
2559                         ff_clean_intra_table_entries(s);
2560
2561                     s->error_status_table[xy]= AC_ERROR;
2562                     continue;
2563                 }
2564                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2565                 if (cbpc < 0){
2566                     fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2567                     return -1;
2568                 }
2569                 if (cbpc > 20)
2570                     cbpc+=3;
2571                 else if (cbpc == 20)
2572                     fprintf(stderr, "Stuffing !");
2573                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2574
2575                 s->mb_intra = ((cbpc & 4) != 0);
2576
2577                 if(s->mb_intra){
2578                     PRINT_MB_TYPE("I");
2579                     s->mbintra_table[xy]= 1;
2580                     s->mb_type[xy]= MB_TYPE_INTRA;
2581                     mot_val[0       ]= mot_val[2       ]=
2582                     mot_val[0+stride]= mot_val[2+stride]= 0;
2583                     mot_val[1       ]= mot_val[3       ]=
2584                     mot_val[1+stride]= mot_val[3+stride]= 0;
2585                     s->error_status_table[xy]= DC_ERROR|AC_ERROR;
2586                 }else{
2587                     if(s->mbintra_table[xy])
2588                         ff_clean_intra_table_entries(s);
2589
2590                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2591                         s->mcsel= get_bits1(&s->gb);
2592                     else s->mcsel= 0;
2593
2594                     if ((cbpc & 16) == 0) {
2595                         PRINT_MB_TYPE("P");
2596                         /* 16x16 motion prediction */
2597                         s->mb_type[xy]= MB_TYPE_INTER;
2598
2599                         h263_pred_motion(s, 0, &pred_x, &pred_y);
2600                         if(!s->mcsel){
2601                             mx = h263_decode_motion(s, pred_x, s->f_code);
2602                             if (mx >= 0xffff)
2603                                 return -1;
2604
2605                             my = h263_decode_motion(s, pred_y, s->f_code);
2606                             if (my >= 0xffff)
2607                                 return -1;
2608                         } else {
2609                             mx = get_amv(s, 0);
2610                             my = get_amv(s, 1);
2611                         }
2612
2613                         mot_val[0       ]= mot_val[2       ] =
2614                         mot_val[0+stride]= mot_val[2+stride]= mx;
2615                         mot_val[1       ]= mot_val[3       ]=
2616                         mot_val[1+stride]= mot_val[3+stride]= my;
2617                     } else {
2618                         int i;
2619                         PRINT_MB_TYPE("4");
2620                         s->mb_type[xy]= MB_TYPE_INTER4V;
2621                         for(i=0;i<4;i++) {
2622                             INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2623                             mx = h263_decode_motion(s, pred_x, s->f_code);
2624                             if (mx >= 0xffff)
2625                                 return -1;
2626
2627                             my = h263_decode_motion(s, pred_y, s->f_code);
2628                             if (my >= 0xffff)
2629                                 return -1;
2630                             mot_val[0] = mx;
2631                             mot_val[1] = my;
2632                         }
2633                     }
2634                     s->error_status_table[xy]= AC_ERROR;
2635                 }
2636             }
2637         }
2638         s->mb_x= 0;
2639     }
2640
2641     return mb_num;
2642 }
2643
2644 /**
2645  * decode second partition.
2646  * @return <0 if an error occured
2647  */
2648 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2649     int mb_num=0;
2650     static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2651
2652     s->mb_x= s->resync_mb_x;
2653     s->first_slice_line=1;
2654     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2655         ff_init_block_index(s);
2656         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2657             const int xy= s->mb_x + s->mb_y*s->mb_width;
2658
2659             mb_num++;
2660             ff_update_block_index(s);
2661             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2662                 s->first_slice_line=0;
2663
2664             if(s->pict_type==I_TYPE){
2665                 int ac_pred= get_bits1(&s->gb);
2666                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2667                 if(cbpy<0){
2668                     fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2669                     return -1;
2670                 }
2671
2672                 s->cbp_table[xy]|= cbpy<<2;
2673                 s->pred_dir_table[xy]|= ac_pred<<7;
2674             }else{ /* P || S_TYPE */
2675                 if(s->mb_type[xy]&MB_TYPE_INTRA){
2676                     int dir=0,i;
2677                     int ac_pred = get_bits1(&s->gb);
2678                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2679
2680                     if(cbpy<0){
2681                         fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2682                         return -1;
2683                     }
2684
2685                     if(s->cbp_table[xy] & 8) {
2686                         change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2687                     }
2688                     s->qscale_table[xy]= s->qscale;
2689
2690                     for(i=0; i<6; i++){
2691                         int dc_pred_dir;
2692                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2693                         if(dc < 0){
2694                             fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2695                             return -1;
2696                         }
2697                         dir<<=1;
2698                         if(dc_pred_dir) dir|=1;
2699                     }
2700                     s->cbp_table[xy]&= 3; //remove dquant
2701                     s->cbp_table[xy]|= cbpy<<2;
2702                     s->pred_dir_table[xy]= dir | (ac_pred<<7);
2703                     s->error_status_table[xy]&= ~DC_ERROR;
2704                 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2705                     s->qscale_table[xy]= s->qscale;
2706                     s->cbp_table[xy]= 0;
2707                 }else{
2708                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2709
2710                     if(cbpy<0){
2711                         fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2712                         return -1;
2713                     }
2714
2715                     if(s->cbp_table[xy] & 8) {
2716                         change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2717                     }
2718                     s->qscale_table[xy]= s->qscale;
2719
2720                     s->cbp_table[xy]&= 3; //remove dquant
2721                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
2722                 }
2723             }
2724         }
2725         if(mb_num >= mb_count) return 0;
2726         s->mb_x= 0;
2727     }
2728     return 0;
2729 }
2730
2731 /**
2732  * decodes the first & second partition
2733  * @return <0 if error (and sets error type in the error_status_table)
2734  */
2735 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2736 {
2737     int mb_num;
2738
2739     mb_num= mpeg4_decode_partition_a(s);
2740     if(mb_num<0)
2741         return -1;
2742
2743     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2744         fprintf(stderr, "slice below monitor ...\n");
2745         return -1;
2746     }
2747
2748     s->mb_num_left= mb_num;
2749
2750     if(s->pict_type==I_TYPE){
2751         if(get_bits(&s->gb, 19)!=DC_MARKER){
2752             fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2753             return -1;
2754         }else
2755             s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2756     }else{
2757         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2758             fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2759             return -1;
2760         }else
2761             s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2762     }
2763
2764     if( mpeg4_decode_partition_b(s, mb_num) < 0){
2765         return -1;
2766     }
2767
2768     s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
2769
2770     return 0;
2771 }
2772
2773 /**
2774  * decode partition C of one MB.
2775  * @return <0 if an error occured
2776  */
2777 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2778 {
2779     int cbp, mb_type;
2780     const int xy= s->mb_x + s->mb_y*s->mb_width;
2781
2782     mb_type= s->mb_type[xy];
2783     cbp = s->cbp_table[xy];
2784
2785     if(s->qscale_table[xy] != s->qscale){
2786         s->qscale= s->qscale_table[xy];
2787         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2788         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2789     }
2790
2791     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2792         int i;
2793         for(i=0; i<4; i++){
2794             s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2795             s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2796         }
2797         s->mb_intra = mb_type&MB_TYPE_INTRA;
2798
2799         if (mb_type&MB_TYPE_SKIPED) {
2800             /* skip mb */
2801             for(i=0;i<6;i++)
2802                 s->block_last_index[i] = -1;
2803             s->mv_dir = MV_DIR_FORWARD;
2804             s->mv_type = MV_TYPE_16X16;
2805             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2806                 s->mcsel=1;
2807                 s->mb_skiped = 0;
2808             }else{
2809                 s->mcsel=0;
2810                 s->mb_skiped = 1;
2811             }
2812         }else if(s->mb_intra){
2813             s->ac_pred = s->pred_dir_table[xy]>>7;
2814
2815             /* decode each block */
2816             for (i = 0; i < 6; i++) {
2817                 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2818                     fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
2819                     return -1;
2820                 }
2821                 cbp+=cbp;
2822             }
2823         }else if(!s->mb_intra){
2824 //            s->mcsel= 0; //FIXME do we need to init that
2825
2826             s->mv_dir = MV_DIR_FORWARD;
2827             if (mb_type&MB_TYPE_INTER4V) {
2828                 s->mv_type = MV_TYPE_8X8;
2829             } else {
2830                 s->mv_type = MV_TYPE_16X16;
2831             }
2832             /* decode each block */
2833             for (i = 0; i < 6; i++) {
2834                 if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
2835                     fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2836                     return -1;
2837                 }
2838                 cbp+=cbp;
2839             }
2840         }
2841     } else { /* I-Frame */
2842         int i;
2843         s->mb_intra = 1;
2844         s->ac_pred = s->pred_dir_table[xy]>>7;
2845
2846         /* decode each block */
2847         for (i = 0; i < 6; i++) {
2848             if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
2849                 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2850                 return -1;
2851             }
2852             cbp+=cbp;
2853         }
2854     }
2855
2856     s->error_status_table[xy]&= ~AC_ERROR;
2857
2858     /* per-MB end of slice check */
2859
2860     if(--s->mb_num_left <= 0){
2861 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
2862         if(mpeg4_is_resync(s))
2863             return SLICE_END;
2864         else
2865             return SLICE_NOEND;
2866     }else{
2867         if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
2868             return SLICE_END;
2869         else
2870             return SLICE_OK;
2871     }
2872 }
2873
2874 int ff_h263_decode_mb(MpegEncContext *s,
2875                       DCTELEM block[6][64])
2876 {
2877     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2878     INT16 *mot_val;
2879     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2880
2881     s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
2882
2883     if(s->mb_x==0) PRINT_MB_TYPE("\n");
2884
2885     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2886         if (get_bits1(&s->gb)) {
2887             /* skip mb */
2888             s->mb_intra = 0;
2889             for(i=0;i<6;i++)
2890                 s->block_last_index[i] = -1;
2891             s->mv_dir = MV_DIR_FORWARD;
2892             s->mv_type = MV_TYPE_16X16;
2893             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2894                 PRINT_MB_TYPE("G");
2895                 s->mcsel=1;
2896                 s->mv[0][0][0]= get_amv(s, 0);
2897                 s->mv[0][0][1]= get_amv(s, 1);
2898
2899                 s->mb_skiped = 0;
2900             }else{
2901                 PRINT_MB_TYPE("S");
2902                 s->mcsel=0;
2903                 s->mv[0][0][0] = 0;
2904                 s->mv[0][0][1] = 0;
2905                 s->mb_skiped = 1;
2906             }
2907             goto end;
2908         }
2909         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2910         //fprintf(stderr, "\tCBPC: %d", cbpc);
2911         if (cbpc < 0)
2912             return -1;
2913         if (cbpc > 20)
2914             cbpc+=3;
2915         else if (cbpc == 20)
2916             fprintf(stderr, "Stuffing !");
2917
2918         dquant = cbpc & 8;
2919         s->mb_intra = ((cbpc & 4) != 0);
2920         if (s->mb_intra) goto intra;
2921
2922         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2923             s->mcsel= get_bits1(&s->gb);
2924         else s->mcsel= 0;
2925         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2926         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2927         if (dquant) {
2928             change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2929         }
2930         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
2931             s->interlaced_dct= get_bits1(&s->gb);
2932
2933         s->mv_dir = MV_DIR_FORWARD;
2934         if ((cbpc & 16) == 0) {
2935             if(s->mcsel){
2936                 PRINT_MB_TYPE("G");
2937                 /* 16x16 global motion prediction */
2938                 s->mv_type = MV_TYPE_16X16;
2939                 mx= get_amv(s, 0);
2940                 my= get_amv(s, 1);
2941                 s->mv[0][0][0] = mx;
2942                 s->mv[0][0][1] = my;
2943             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2944                 PRINT_MB_TYPE("f");
2945                 /* 16x8 field motion prediction */
2946                 s->mv_type= MV_TYPE_FIELD;
2947
2948                 s->field_select[0][0]= get_bits1(&s->gb);
2949                 s->field_select[0][1]= get_bits1(&s->gb);
2950
2951                 h263_pred_motion(s, 0, &pred_x, &pred_y);
2952
2953                 for(i=0; i<2; i++){
2954                     mx = h263_decode_motion(s, pred_x, s->f_code);
2955                     if (mx >= 0xffff)
2956                         return -1;
2957
2958                     my = h263_decode_motion(s, pred_y/2, s->f_code);
2959                     if (my >= 0xffff)
2960                         return -1;
2961
2962                     s->mv[0][i][0] = mx;
2963                     s->mv[0][i][1] = my;
2964                 }
2965             }else{
2966                 PRINT_MB_TYPE("P");
2967                 /* 16x16 motion prediction */
2968                 s->mv_type = MV_TYPE_16X16;
2969                 h263_pred_motion(s, 0, &pred_x, &pred_y);
2970                 if (s->umvplus_dec)
2971                    mx = h263p_decode_umotion(s, pred_x);
2972                 else
2973                    mx = h263_decode_motion(s, pred_x, s->f_code);
2974
2975                 if (mx >= 0xffff)
2976                     return -1;
2977
2978                 if (s->umvplus_dec)
2979                    my = h263p_decode_umotion(s, pred_y);
2980                 else
2981                    my = h263_decode_motion(s, pred_y, s->f_code);
2982
2983                 if (my >= 0xffff)
2984                     return -1;
2985                 s->mv[0][0][0] = mx;
2986                 s->mv[0][0][1] = my;
2987
2988                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2989                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2990             }
2991         } else {
2992             PRINT_MB_TYPE("4");
2993             s->mv_type = MV_TYPE_8X8;
2994             for(i=0;i<4;i++) {
2995                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2996                 if (s->umvplus_dec)
2997                   mx = h263p_decode_umotion(s, pred_x);
2998                 else
2999                   mx = h263_decode_motion(s, pred_x, s->f_code);
3000                 if (mx >= 0xffff)
3001                     return -1;
3002
3003                 if (s->umvplus_dec)
3004                   my = h263p_decode_umotion(s, pred_y);
3005                 else
3006                   my = h263_decode_motion(s, pred_y, s->f_code);
3007                 if (my >= 0xffff)
3008                     return -1;
3009                 s->mv[0][i][0] = mx;
3010                 s->mv[0][i][1] = my;
3011                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3012                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3013                 mot_val[0] = mx;
3014                 mot_val[1] = my;
3015             }
3016         }
3017     } else if(s->pict_type==B_TYPE) {
3018         int modb1; // first bit of modb
3019         int modb2; // second bit of modb
3020         int mb_type;
3021         uint16_t time_pp;
3022         uint16_t time_pb;
3023         int xy;
3024
3025         s->mb_intra = 0; //B-frames never contain intra blocks
3026         s->mcsel=0;      //     ...               true gmc blocks
3027
3028         if(s->mb_x==0){
3029             for(i=0; i<2; i++){
3030                 s->last_mv[i][0][0]=
3031                 s->last_mv[i][0][1]=
3032                 s->last_mv[i][1][0]=
3033                 s->last_mv[i][1][1]= 0;
3034             }
3035         }
3036
3037         /* if we skipped it in the future P Frame than skip it now too */
3038         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
3039
3040         if(s->mb_skiped){
3041                 /* skip mb */
3042             for(i=0;i<6;i++)
3043                 s->block_last_index[i] = -1;
3044
3045             s->mv_dir = MV_DIR_FORWARD;
3046             s->mv_type = MV_TYPE_16X16;
3047             s->mv[0][0][0] = 0;
3048             s->mv[0][0][1] = 0;
3049             s->mv[1][0][0] = 0;
3050             s->mv[1][0][1] = 0;
3051             PRINT_MB_TYPE("s");
3052             goto end;
3053         }
3054
3055         modb1= get_bits1(&s->gb);
3056         if(modb1){
3057             mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3058             cbp=0;
3059         }else{
3060             int field_mv;
3061
3062             modb2= get_bits1(&s->gb);
3063             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3064             if(modb2) cbp= 0;
3065             else      cbp= get_bits(&s->gb, 6);
3066
3067             if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
3068                 if(get_bits1(&s->gb)){
3069                     change_qscale(s, get_bits1(&s->gb)*4 - 2);
3070                 }
3071             }
3072             field_mv=0;
3073
3074             if(!s->progressive_sequence){
3075                 if(cbp)
3076                     s->interlaced_dct= get_bits1(&s->gb);
3077
3078                 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3079                     field_mv=1;
3080
3081                     if(mb_type!=MB_TYPE_B_BACKW){
3082                         s->field_select[0][0]= get_bits1(&s->gb);
3083                         s->field_select[0][1]= get_bits1(&s->gb);
3084                     }
3085                     if(mb_type!=MB_TYPE_B_FORW){
3086                         s->field_select[1][0]= get_bits1(&s->gb);
3087                         s->field_select[1][1]= get_bits1(&s->gb);
3088                     }
3089                 }
3090             }
3091
3092             s->mv_dir = 0;
3093             if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3094                 s->mv_type= MV_TYPE_16X16;
3095                 if(mb_type!=MB_TYPE_B_BACKW){
3096                     s->mv_dir = MV_DIR_FORWARD;
3097
3098                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3099                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3100                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3101                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3102                 }
3103
3104                 if(mb_type!=MB_TYPE_B_FORW){
3105                     s->mv_dir |= MV_DIR_BACKWARD;
3106
3107                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3108                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3109                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3110                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3111                 }
3112                 if(mb_type!=MB_TYPE_B_DIRECT)
3113                     PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3114             }else if(mb_type!=MB_TYPE_B_DIRECT){
3115                 s->mv_type= MV_TYPE_FIELD;
3116
3117                 if(mb_type!=MB_TYPE_B_BACKW){
3118                     s->mv_dir = MV_DIR_FORWARD;
3119
3120                     for(i=0; i<2; i++){
3121                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3122                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3123                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3124                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3125                     }
3126                 }
3127
3128                 if(mb_type!=MB_TYPE_B_FORW){
3129                     s->mv_dir |= MV_DIR_BACKWARD;
3130
3131                     for(i=0; i<2; i++){
3132                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3133                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3134                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3135                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3136                     }
3137                 }
3138                 if(mb_type!=MB_TYPE_B_DIRECT)
3139                     PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3140             }
3141         }
3142
3143         if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3144             int mb_index= s->mb_x + s->mb_y*s->mb_width;
3145             int i;
3146
3147             if(mb_type==4)
3148                 mx=my=0;
3149             else{
3150                 mx = h263_decode_motion(s, 0, 1);
3151                 my = h263_decode_motion(s, 0, 1);
3152             }
3153
3154             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3155             xy= s->block_index[0];
3156             time_pp= s->pp_time;
3157             time_pb= s->pb_time;
3158
3159             //FIXME avoid divides
3160             switch(s->co_located_type_table[mb_index]){
3161             case 0:
3162                 s->mv_type= MV_TYPE_16X16;
3163                 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3164                 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3165                 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
3166                                     : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3167                 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
3168                                     : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3169                 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
3170                 break;
3171             case CO_LOCATED_TYPE_4MV:
3172                 s->mv_type = MV_TYPE_8X8;
3173                 for(i=0; i<4; i++){
3174                     xy= s->block_index[i];
3175                     s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3176                     s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3177                     s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
3178                                         : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3179                     s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
3180                                         : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3181                 }
3182                 PRINT_MB_TYPE("4");
3183                 break;
3184             case CO_LOCATED_TYPE_FIELDMV:
3185                 s->mv_type = MV_TYPE_FIELD;
3186                 for(i=0; i<2; i++){
3187                     if(s->top_field_first){
3188                         time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
3189                         time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
3190                     }else{
3191                         time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
3192                         time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
3193                     }
3194                     s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
3195                     s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
3196                     s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
3197                                         : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
3198                     s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
3199                                         : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
3200                 }
3201                 PRINT_MB_TYPE("=");
3202                 break;
3203             }
3204         }
3205
3206         if(mb_type<0 || mb_type>4){
3207             printf("illegal MB_type\n");
3208             return -1;
3209         }
3210     } else { /* I-Frame */
3211         cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3212         if (cbpc < 0)
3213             return -1;
3214         dquant = cbpc & 4;
3215         s->mb_intra = 1;
3216 intra:
3217         s->ac_pred = 0;
3218         if (s->h263_pred || s->h263_aic) {
3219             s->ac_pred = get_bits1(&s->gb);
3220             if (s->ac_pred && s->h263_aic)
3221                 s->h263_aic_dir = get_bits1(&s->gb);
3222         }
3223         PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3224
3225         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3226         if(cbpy<0) return -1;
3227         cbp = (cbpc & 3) | (cbpy << 2);
3228         if (dquant) {
3229             change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3230         }
3231
3232         if(!s->progressive_sequence)
3233             s->interlaced_dct= get_bits1(&s->gb);
3234
3235         /* decode each block */
3236         if (s->h263_pred) {
3237             for (i = 0; i < 6; i++) {
3238                 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3239                     return -1;
3240                 cbp+=cbp;
3241             }
3242         } else {
3243             for (i = 0; i < 6; i++) {
3244                 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3245                     return -1;
3246                 cbp+=cbp;
3247             }
3248         }
3249         goto end;
3250     }
3251
3252     /* decode each block */
3253     if (s->h263_pred) {
3254         for (i = 0; i < 6; i++) {
3255             if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
3256                 return -1;
3257             cbp+=cbp;
3258         }
3259     } else {
3260         for (i = 0; i < 6; i++) {
3261             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3262                 return -1;
3263             cbp+=cbp;
3264         }
3265     }
3266 end:
3267
3268         /* per-MB end of slice check */
3269     if(s->codec_id==CODEC_ID_MPEG4){
3270         if(mpeg4_is_resync(s)){
3271             if(s->pict_type==B_TYPE && s->mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
3272                 return SLICE_OK;
3273             return SLICE_END;
3274         }
3275     }else{
3276         if(get_bits_count(&s->gb) + 7 >= s->gb.size*8){
3277             int v= show_bits(&s->gb, 8) >> (((get_bits_count(&s->gb)-1)&7)+1);
3278             if(v==0)
3279                 return SLICE_END;
3280         }else{
3281             if(show_bits(&s->gb, 16)==0)
3282                 return SLICE_END;
3283         }
3284     }
3285
3286     return SLICE_OK;
3287 }
3288
3289 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3290 {
3291     int code, val, sign, shift, l;
3292     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3293     if (code < 0)
3294         return 0xffff;
3295
3296     if (code == 0)
3297         return pred;
3298
3299     sign = get_bits1(&s->gb);
3300     shift = f_code - 1;
3301     val = (code - 1) << shift;
3302     if (shift > 0)
3303         val |= get_bits(&s->gb, shift);
3304     val++;
3305     if (sign)
3306         val = -val;
3307     val += pred;
3308
3309     /* modulo decoding */
3310     if (!s->h263_long_vectors) {
3311         l = 1 << (f_code + 4);
3312         if (val < -l) {
3313             val += l<<1;
3314         } else if (val >= l) {
3315             val -= l<<1;
3316         }
3317     } else {
3318         /* horrible h263 long vector mode */
3319         if (pred < -31 && val < -63)
3320             val += 64;
3321         if (pred > 32 && val > 63)
3322             val -= 64;
3323
3324     }
3325     return val;
3326 }
3327
3328 /* Decodes RVLC of H.263+ UMV */
3329 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3330 {
3331    int code = 0, sign;
3332
3333    if (get_bits1(&s->gb)) /* Motion difference = 0 */
3334       return pred;
3335
3336    code = 2 + get_bits1(&s->gb);
3337
3338    while (get_bits1(&s->gb))
3339    {
3340       code <<= 1;
3341       code += get_bits1(&s->gb);
3342    }
3343    sign = code & 1;
3344    code >>= 1;
3345
3346    code = (sign) ? (pred - code) : (pred + code);
3347 #ifdef DEBUG
3348    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3349 #endif
3350    return code;
3351
3352 }
3353
3354 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3355                              int n, int coded)
3356 {
3357     int code, level, i, j, last, run;
3358     RLTable *rl = &rl_inter;
3359     const UINT8 *scan_table;
3360
3361     scan_table = s->intra_scantable.permutated;
3362     if (s->h263_aic && s->mb_intra) {
3363         rl = &rl_intra_aic;
3364         i = 0;
3365         if (s->ac_pred) {
3366             if (s->h263_aic_dir)
3367                 scan_table = s->intra_v_scantable.permutated; /* left */
3368             else
3369                 scan_table = s->intra_h_scantable.permutated; /* top */
3370         }
3371     } else if (s->mb_intra) {
3372         /* DC coef */
3373         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3374             int component, diff;
3375             component = (n <= 3 ? 0 : n - 4 + 1);
3376             level = s->last_dc[component];
3377             if (s->rv10_first_dc_coded[component]) {
3378                 diff = rv_decode_dc(s, n);
3379                 if (diff == 0xffff)
3380                     return -1;
3381                 level += diff;
3382                 level = level & 0xff; /* handle wrap round */
3383                 s->last_dc[component] = level;
3384             } else {
3385                 s->rv10_first_dc_coded[component] = 1;
3386             }
3387         } else {
3388             level = get_bits(&s->gb, 8);
3389             if (level == 255)
3390                 level = 128;
3391         }
3392         block[0] = level;
3393         i = 1;
3394     } else {
3395         i = 0;
3396     }
3397     if (!coded) {
3398         if (s->mb_intra && s->h263_aic)
3399             goto not_coded;
3400         s->block_last_index[n] = i - 1;
3401         return 0;
3402     }
3403
3404     for(;;) {
3405         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3406         if (code < 0){
3407             fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3408             return -1;
3409         }
3410         if (code == rl->n) {
3411             /* escape */
3412             last = get_bits1(&s->gb);
3413             run = get_bits(&s->gb, 6);
3414             level = (INT8)get_bits(&s->gb, 8);
3415             if (s->h263_rv10 && level == -128) {
3416                 /* XXX: should patch encoder too */
3417                 level = get_bits(&s->gb, 12);
3418                 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3419             }
3420         } else {
3421             run = rl->table_run[code];
3422             level = rl->table_level[code];
3423             last = code >= rl->last;
3424             if (get_bits1(&s->gb))
3425                 level = -level;
3426         }
3427         i += run;
3428         if (i >= 64){
3429             fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3430             return -1;
3431         }
3432         j = scan_table[i];
3433         block[j] = level;
3434         if (last)
3435             break;
3436         i++;
3437     }
3438 not_coded:
3439     if (s->mb_intra && s->h263_aic) {
3440         h263_pred_acdc(s, block, n);
3441         i = 63;
3442     }
3443     s->block_last_index[n] = i;
3444     return 0;
3445 }
3446
3447 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3448 {
3449     int level, pred, code;
3450     UINT16 *dc_val;
3451
3452     if (n < 4)
3453         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3454     else
3455         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3456     if (code < 0 || code > 9 /* && s->nbit<9 */){
3457         fprintf(stderr, "illegal dc vlc\n");
3458         return -1;
3459     }
3460     if (code == 0) {
3461         level = 0;
3462     } else {
3463         level = get_bits(&s->gb, code);
3464         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3465             level = - (level ^ ((1 << code) - 1));
3466         if (code > 8){
3467             if(get_bits1(&s->gb)==0){ /* marker */
3468                 if(s->error_resilience>=2){
3469                     fprintf(stderr, "dc marker bit missing\n");
3470                     return -1;
3471                 }
3472             }
3473         }
3474     }
3475     pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3476     level += pred;
3477     if (level < 0){
3478         if(s->error_resilience>=3){
3479             fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3480             return -1;
3481         }
3482         level = 0;
3483     }
3484     if (n < 4) {
3485         *dc_val = level * s->y_dc_scale;
3486     } else {
3487         *dc_val = level * s->c_dc_scale;
3488     }
3489     if(s->error_resilience>=3){
3490         if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3491             fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3492             return -1;
3493         }
3494     }
3495     return level;
3496 }
3497
3498 /**
3499  * decodes a block.
3500  * @return <0 if an error occured
3501  */
3502 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3503                               int n, int coded, int intra)
3504 {
3505     int level, i, last, run;
3506     int dc_pred_dir;
3507     RLTable * rl;
3508     RL_VLC_ELEM * rl_vlc;
3509     const UINT8 * scan_table;
3510     int qmul, qadd;
3511
3512     if(intra) {
3513         /* DC coef */
3514         if(s->partitioned_frame){
3515             level = s->dc_val[0][ s->block_index[n] ];
3516             if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3517             else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3518             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3519         }else{
3520             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3521             if (level < 0)
3522                 return -1;
3523         }
3524         block[0] = level;
3525         i = 0;
3526         if (!coded)
3527             goto not_coded;
3528         rl = &rl_intra;
3529         rl_vlc = rl_intra.rl_vlc[0];
3530         if (s->ac_pred) {
3531             if (dc_pred_dir == 0)
3532                 scan_table = s->intra_v_scantable.permutated; /* left */
3533             else
3534                 scan_table = s->intra_h_scantable.permutated; /* top */
3535         } else {
3536             scan_table = s->intra_scantable.permutated;
3537         }
3538         qmul=1;
3539         qadd=0;
3540     } else {
3541         i = -1;
3542         if (!coded) {
3543             s->block_last_index[n] = i;
3544             return 0;
3545         }
3546         rl = &rl_inter;
3547
3548         scan_table = s->intra_scantable.permutated;
3549
3550         if(s->mpeg_quant){
3551             qmul=1;
3552             qadd=0;
3553             rl_vlc = rl_inter.rl_vlc[0];
3554         }else{
3555             qmul = s->qscale << 1;
3556             qadd = (s->qscale - 1) | 1;
3557             rl_vlc = rl_inter.rl_vlc[s->qscale];
3558         }
3559     }
3560   {
3561     OPEN_READER(re, &s->gb);
3562     for(;;) {
3563         UPDATE_CACHE(re, &s->gb);
3564         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3565         if (level==0) {
3566             int cache;
3567             cache= GET_CACHE(re, &s->gb);
3568             /* escape */
3569             if (cache&0x80000000) {
3570                 if (cache&0x40000000) {
3571                     /* third escape */
3572                     SKIP_CACHE(re, &s->gb, 2);
3573                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3574                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3575                     SKIP_COUNTER(re, &s->gb, 2+1+6);
3576                     UPDATE_CACHE(re, &s->gb);
3577
3578                     if(SHOW_UBITS(re, &s->gb, 1)==0){
3579                         fprintf(stderr, "1. marker bit missing in 3. esc\n");
3580                         return -1;
3581                     }; SKIP_CACHE(re, &s->gb, 1);
3582
3583                     level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3584
3585                     if(SHOW_UBITS(re, &s->gb, 1)==0){
3586                         fprintf(stderr, "2. marker bit missing in 3. esc\n");
3587                         return -1;
3588                     }; LAST_SKIP_CACHE(re, &s->gb, 1);
3589
3590                     SKIP_COUNTER(re, &s->gb, 1+12+1);
3591
3592                     if(level*s->qscale>1024 || level*s->qscale<-1024){
3593                         fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3594                         return -1;
3595                     }
3596 #if 1
3597                     {
3598                         const int abs_level= ABS(level);
3599                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN && ((s->workaround_bugs&FF_BUG_AC_VLC)==0)){
3600                             const int run1= run - rl->max_run[last][abs_level] - 1;
3601                             if(abs_level <= rl->max_level[last][run]){
3602                                 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3603                                 return -1;
3604                             }
3605                             if(abs_level <= rl->max_level[last][run]*2){
3606                                 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3607                                 return -1;
3608                             }
3609                             if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3610                                 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3611                                 return -1;
3612                             }
3613                         }
3614                     }
3615 #endif
3616                     if (level>0) level= level * qmul + qadd;
3617                     else         level= level * qmul - qadd;
3618
3619                     i+= run + 1;
3620                     if(last) i+=192;
3621                 } else {
3622                     /* second escape */
3623 #if MIN_CACHE_BITS < 20
3624                     LAST_SKIP_BITS(re, &s->gb, 2);
3625                     UPDATE_CACHE(re, &s->gb);
3626 #else
3627                     SKIP_BITS(re, &s->gb, 2);
3628 #endif
3629                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3630                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3631                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3632                     LAST_SKIP_BITS(re, &s->gb, 1);
3633                 }
3634             } else {
3635                 /* first escape */
3636 #if MIN_CACHE_BITS < 19
3637                 LAST_SKIP_BITS(re, &s->gb, 1);
3638                 UPDATE_CACHE(re, &s->gb);
3639 #else
3640                 SKIP_BITS(re, &s->gb, 1);
3641 #endif
3642                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3643                 i+= run;
3644                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3645                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3646                 LAST_SKIP_BITS(re, &s->gb, 1);
3647             }
3648         } else {
3649             i+= run;
3650             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3651             LAST_SKIP_BITS(re, &s->gb, 1);
3652         }
3653         if (i > 62){
3654             i-= 192;
3655             if(i&(~63)){
3656                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3657                 return -1;
3658             }
3659
3660             block[scan_table[i]] = level;
3661             break;
3662         }
3663
3664         block[scan_table[i]] = level;
3665     }
3666     CLOSE_READER(re, &s->gb);
3667   }
3668  not_coded:
3669     if (s->mb_intra) {
3670         mpeg4_pred_ac(s, block, n, dc_pred_dir);
3671         if (s->ac_pred) {
3672             i = 63; /* XXX: not optimal */
3673         }
3674     }
3675     s->block_last_index[n] = i;
3676     return 0;
3677 }
3678
3679 /* most is hardcoded. should extend to handle all h263 streams */
3680 int h263_decode_picture_header(MpegEncContext *s)
3681 {
3682     int format, width, height;
3683
3684     /* picture start code */
3685     if (get_bits(&s->gb, 22) != 0x20) {
3686         fprintf(stderr, "Bad picture start code\n");
3687         return -1;
3688     }
3689     /* temporal reference */
3690     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3691
3692     /* PTYPE starts here */
3693     if (get_bits1(&s->gb) != 1) {
3694         /* marker */
3695         fprintf(stderr, "Bad marker\n");
3696         return -1;
3697     }
3698     if (get_bits1(&s->gb) != 0) {
3699         fprintf(stderr, "Bad H263 id\n");
3700         return -1;      /* h263 id */
3701     }
3702     skip_bits1(&s->gb); /* split screen off */
3703     skip_bits1(&s->gb); /* camera  off */
3704     skip_bits1(&s->gb); /* freeze picture release off */
3705
3706     /* Reset GOB number */
3707     s->gob_number = 0;
3708
3709     format = get_bits(&s->gb, 3);
3710     /*
3711         0    forbidden
3712         1    sub-QCIF
3713         10   QCIF
3714         7       extended PTYPE (PLUSPTYPE)
3715     */
3716
3717     if (format != 7 && format != 6) {
3718         s->h263_plus = 0;
3719         /* H.263v1 */
3720         width = h263_format[format][0];
3721         height = h263_format[format][1];
3722         if (!width)
3723             return -1;
3724
3725         s->width = width;
3726         s->height = height;
3727         s->pict_type = I_TYPE + get_bits1(&s->gb);
3728
3729         s->unrestricted_mv = get_bits1(&s->gb);
3730         s->h263_long_vectors = s->unrestricted_mv;
3731
3732         if (get_bits1(&s->gb) != 0) {
3733             fprintf(stderr, "H263 SAC not supported\n");
3734             return -1;  /* SAC: off */
3735         }
3736         if (get_bits1(&s->gb) != 0) {
3737             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3738         }
3739
3740         if (get_bits1(&s->gb) != 0) {
3741             fprintf(stderr, "H263 PB frame not supported\n");
3742             return -1;  /* not PB frame */
3743         }
3744         s->qscale = get_bits(&s->gb, 5);
3745         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
3746     } else {
3747         int ufep;
3748
3749         /* H.263v2 */
3750         s->h263_plus = 1;
3751         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3752
3753         /* ufep other than 0 and 1 are reserved */
3754         if (ufep == 1) {
3755             /* OPPTYPE */
3756             format = get_bits(&s->gb, 3);
3757             dprintf("ufep=1, format: %d\n", format);
3758             skip_bits(&s->gb,1); /* Custom PCF */
3759             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3760             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3761             if (get_bits1(&s->gb) != 0) {
3762                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3763             }
3764             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3765                 s->h263_aic = 1;
3766             }
3767
3768             skip_bits(&s->gb, 7);
3769             /* these are the 7 bits: (in order of appearence  */
3770             /* Deblocking Filter */
3771             /* Slice Structured */
3772             /* Reference Picture Selection */
3773             /* Independent Segment Decoding */
3774             /* Alternative Inter VLC */
3775             /* Modified Quantization */
3776             /* Prevent start code emulation */
3777
3778             skip_bits(&s->gb, 3); /* Reserved */
3779         } else if (ufep != 0) {
3780             fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3781             return -1;
3782         }
3783
3784         /* MPPTYPE */
3785         s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3786         dprintf("pict_type: %d\n", s->pict_type);
3787         if (s->pict_type != I_TYPE &&
3788             s->pict_type != P_TYPE)
3789             return -1;
3790         skip_bits(&s->gb, 2);
3791         s->no_rounding = get_bits1(&s->gb);
3792         dprintf("RTYPE: %d\n", s->no_rounding);
3793         skip_bits(&s->gb, 4);
3794
3795         /* Get the picture dimensions */
3796         if (ufep) {
3797             if (format == 6) {
3798                 /* Custom Picture Format (CPFMT) */
3799                 s->aspect_ratio_info = get_bits(&s->gb, 4);
3800                 dprintf("aspect: %d\n", s->aspect_ratio_info);
3801                 /* aspect ratios:
3802                 0 - forbidden
3803                 1 - 1:1
3804                 2 - 12:11 (CIF 4:3)
3805                 3 - 10:11 (525-type 4:3)
3806                 4 - 16:11 (CIF 16:9)
3807                 5 - 40:33 (525-type 16:9)
3808                 6-14 - reserved
3809                 */
3810                 width = (get_bits(&s->gb, 9) + 1) * 4;
3811                 skip_bits1(&s->gb);
3812                 height = get_bits(&s->gb, 9) * 4;
3813                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3814                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3815                     /* aspected dimensions */
3816                     s->aspected_width = get_bits(&s->gb, 8);
3817                     s->aspected_height = get_bits(&s->gb, 8);
3818                 }
3819             } else {
3820                 width = h263_format[format][0];
3821                 height = h263_format[format][1];
3822             }
3823             if ((width == 0) || (height == 0))
3824                 return -1;
3825             s->width = width;
3826             s->height = height;
3827             if (s->umvplus_dec) {
3828                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3829             }
3830         }
3831
3832         s->qscale = get_bits(&s->gb, 5);
3833     }
3834     /* PEI */
3835     while (get_bits1(&s->gb) != 0) {
3836         skip_bits(&s->gb, 8);
3837     }
3838     s->f_code = 1;
3839
3840     if(s->h263_aic){
3841          s->y_dc_scale_table=
3842          s->c_dc_scale_table= h263_aic_dc_scale_table;
3843     }else{
3844         s->y_dc_scale_table=
3845         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3846     }
3847
3848     return 0;
3849 }
3850
3851 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3852 {
3853     int i;
3854     int a= 2<<s->sprite_warping_accuracy;
3855     int rho= 3-s->sprite_warping_accuracy;
3856     int r=16/a;
3857     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3858     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3859     int sprite_ref[4][2];
3860     int virtual_ref[2][2];
3861     int w2, h2, w3, h3;
3862     int alpha=0, beta=0;
3863     int w= s->width;
3864     int h= s->height;
3865     int min_ab;
3866
3867     for(i=0; i<s->num_sprite_warping_points; i++){
3868         int length;
3869         int x=0, y=0;
3870
3871         length= get_vlc(&s->gb, &sprite_trajectory);
3872         if(length){
3873             x= get_bits(&s->gb, length);
3874
3875             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3876                 x = - (x ^ ((1 << length) - 1));
3877         }
3878         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3879
3880         length= get_vlc(&s->gb, &sprite_trajectory);
3881         if(length){
3882             y=get_bits(&s->gb, length);
3883
3884             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3885                 y = - (y ^ ((1 << length) - 1));
3886         }
3887         skip_bits1(&s->gb); /* marker bit */
3888 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3889         d[i][0]= x;
3890         d[i][1]= y;
3891     }
3892
3893     while((1<<alpha)<w) alpha++;
3894     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3895     w2= 1<<alpha;
3896     h2= 1<<beta;
3897
3898 // Note, the 4th point isnt used for GMC
3899     if(s->divx_version==500 && s->divx_build==413){
3900         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3901         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3902         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3903         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3904         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3905         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3906     } else {
3907         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3908         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3909         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3910         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3911         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3912         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3913     }
3914 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3915     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3916
3917 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3918 // perhaps it should be reordered to be more readable ...
3919 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3920 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3921     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
3922         + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
3923     virtual_ref[0][1]= 16*vop_ref[0][1]
3924         + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
3925     virtual_ref[1][0]= 16*vop_ref[0][0]
3926         + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
3927     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
3928         + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
3929
3930     switch(s->num_sprite_warping_points)
3931     {
3932         case 0:
3933             s->sprite_offset[0][0]= 0;
3934             s->sprite_offset[0][1]= 0;
3935             s->sprite_offset[1][0]= 0;
3936             s->sprite_offset[1][1]= 0;
3937             s->sprite_delta[0][0]= a;
3938             s->sprite_delta[0][1]= 0;
3939             s->sprite_delta[1][0]= 0;
3940             s->sprite_delta[1][1]= a;
3941             s->sprite_shift[0]= 0;
3942             s->sprite_shift[1]= 0;
3943             break;
3944         case 1: //GMC only
3945             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3946             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3947             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3948             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3949             s->sprite_delta[0][0]= a;
3950             s->sprite_delta[0][1]= 0;
3951             s->sprite_delta[1][0]= 0;
3952             s->sprite_delta[1][1]= a;
3953             s->sprite_shift[0]= 0;
3954             s->sprite_shift[1]= 0;
3955             break;
3956         case 2:
3957             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3958                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3959                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
3960                                                   + (1<<(alpha+rho-1));
3961             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3962                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3963                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
3964                                                   + (1<<(alpha+rho-1));
3965             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3966                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3967                                      +2*w2*r*sprite_ref[0][0]
3968                                      - 16*w2
3969                                      + (1<<(alpha+rho+1)));
3970             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
3971                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3972                                      +2*w2*r*sprite_ref[0][1]
3973                                      - 16*w2
3974                                      + (1<<(alpha+rho+1)));
3975             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3976             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
3977             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3978             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3979
3980             s->sprite_shift[0]= alpha+rho;
3981             s->sprite_shift[1]= alpha+rho+2;
3982             break;
3983         case 3:
3984             min_ab= MIN(alpha, beta);
3985             w3= w2>>min_ab;
3986             h3= h2>>min_ab;
3987             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
3988                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
3989                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
3990                                    + (1<<(alpha+beta+rho-min_ab-1));
3991             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
3992                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
3993                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
3994                                    + (1<<(alpha+beta+rho-min_ab-1));
3995             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
3996                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
3997                                    + 2*w2*h3*r*sprite_ref[0][0]
3998                                    - 16*w2*h3
3999                                    + (1<<(alpha+beta+rho-min_ab+1));
4000             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4001                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4002                                    + 2*w2*h3*r*sprite_ref[0][1]
4003                                    - 16*w2*h3
4004                                    + (1<<(alpha+beta+rho-min_ab+1));
4005             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4006             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4007             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4008             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4009
4010             s->sprite_shift[0]= alpha + beta + rho - min_ab;
4011             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4012             break;
4013     }
4014     /* try to simplify the situation */
4015     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4016        && s->sprite_delta[0][1] == 0
4017        && s->sprite_delta[1][0] == 0
4018        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4019     {
4020         s->sprite_offset[0][0]>>=s->sprite_shift[0];
4021         s->sprite_offset[0][1]>>=s->sprite_shift[0];
4022         s->sprite_offset[1][0]>>=s->sprite_shift[1];
4023         s->sprite_offset[1][1]>>=s->sprite_shift[1];
4024         s->sprite_delta[0][0]= a;
4025         s->sprite_delta[0][1]= 0;
4026         s->sprite_delta[1][0]= 0;
4027         s->sprite_delta[1][1]= a;
4028         s->sprite_shift[0]= 0;
4029         s->sprite_shift[1]= 0;
4030         s->real_sprite_warping_points=1;
4031     }
4032     else{
4033         int shift_y= 16 - s->sprite_shift[0];
4034         int shift_c= 16 - s->sprite_shift[1];
4035 //printf("shifts %d %d\n", shift_y, shift_c);
4036         for(i=0; i<2; i++){
4037             s->sprite_offset[0][i]<<= shift_y;
4038             s->sprite_offset[1][i]<<= shift_c;
4039             s->sprite_delta[0][i]<<= shift_y;
4040             s->sprite_delta[1][i]<<= shift_y;
4041             s->sprite_shift[i]= 16;
4042         }
4043         s->real_sprite_warping_points= s->num_sprite_warping_points;
4044     }
4045 #if 0
4046 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4047     vop_ref[0][0], vop_ref[0][1],
4048     vop_ref[1][0], vop_ref[1][1],
4049     vop_ref[2][0], vop_ref[2][1],
4050     sprite_ref[0][0], sprite_ref[0][1],
4051     sprite_ref[1][0], sprite_ref[1][1],
4052     sprite_ref[2][0], sprite_ref[2][1],
4053     virtual_ref[0][0], virtual_ref[0][1],
4054     virtual_ref[1][0], virtual_ref[1][1]
4055     );
4056
4057 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4058     s->sprite_offset[0][0], s->sprite_offset[0][1],
4059     s->sprite_delta[0][0], s->sprite_delta[0][1],
4060     s->sprite_delta[1][0], s->sprite_delta[1][1],
4061     s->sprite_shift[0]
4062     );
4063 #endif
4064 }
4065
4066 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4067     int width, height, vo_ver_id;
4068
4069     /* vol header */
4070     skip_bits(gb, 1); /* random access */
4071     s->vo_type= get_bits(gb, 8);
4072     if (get_bits1(gb) != 0) { /* is_ol_id */
4073         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4074         skip_bits(gb, 3); /* vo_priority */
4075     } else {
4076         vo_ver_id = 1;
4077     }
4078 //printf("vo type:%d\n",s->vo_type);
4079     s->aspect_ratio_info= get_bits(gb, 4);
4080     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4081         s->aspected_width = get_bits(gb, 8); // par_width
4082         s->aspected_height = get_bits(gb, 8); // par_height
4083     }
4084
4085     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4086         int chroma_format= get_bits(gb, 2);
4087         if(chroma_format!=1){
4088             printf("illegal chroma format\n");
4089         }
4090         s->low_delay= get_bits1(gb);
4091         if(get_bits1(gb)){ /* vbv parameters */
4092             get_bits(gb, 15);   /* first_half_bitrate */
4093             skip_bits1(gb);     /* marker */
4094             get_bits(gb, 15);   /* latter_half_bitrate */
4095             skip_bits1(gb);     /* marker */
4096             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
4097             skip_bits1(gb);     /* marker */
4098             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
4099             get_bits(gb, 11);   /* first_half_vbv_occupancy */
4100             skip_bits1(gb);     /* marker */
4101             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
4102             skip_bits1(gb);     /* marker */
4103         }
4104     }else{
4105         // set low delay flag only once so the smart? low delay detection wont be overriden
4106         if(s->picture_number==0)
4107             s->low_delay=0;
4108     }
4109
4110     s->shape = get_bits(gb, 2); /* vol shape */
4111     if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4112     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4113         printf("Gray shape not supported\n");
4114         skip_bits(gb, 4);  //video_object_layer_shape_extension
4115     }
4116
4117     skip_bits1(gb);   /* marker */
4118
4119     s->time_increment_resolution = get_bits(gb, 16);
4120
4121     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4122     if (s->time_increment_bits < 1)
4123         s->time_increment_bits = 1;
4124     skip_bits1(gb);   /* marker */
4125
4126     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4127         skip_bits(gb, s->time_increment_bits);
4128     }
4129
4130     if (s->shape != BIN_ONLY_SHAPE) {
4131         if (s->shape == RECT_SHAPE) {
4132             skip_bits1(gb);   /* marker */
4133             width = get_bits(gb, 13);
4134             skip_bits1(gb);   /* marker */
4135             height = get_bits(gb, 13);
4136             skip_bits1(gb);   /* marker */
4137             if(width && height){ /* they should be non zero but who knows ... */
4138                 s->width = width;
4139                 s->height = height;
4140 //                printf("width/height: %d %d\n", width, height);
4141             }
4142         }
4143
4144         s->progressive_sequence= get_bits1(gb)^1;
4145         if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4146         if (vo_ver_id == 1) {
4147             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4148         } else {
4149             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4150         }
4151         if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4152         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4153             if(s->vol_sprite_usage==STATIC_SPRITE){
4154                 s->sprite_width = get_bits(gb, 13);
4155                 skip_bits1(gb); /* marker */
4156                 s->sprite_height= get_bits(gb, 13);
4157                 skip_bits1(gb); /* marker */
4158                 s->sprite_left  = get_bits(gb, 13);
4159                 skip_bits1(gb); /* marker */
4160                 s->sprite_top   = get_bits(gb, 13);
4161                 skip_bits1(gb); /* marker */
4162             }
4163             s->num_sprite_warping_points= get_bits(gb, 6);
4164             s->sprite_warping_accuracy = get_bits(gb, 2);
4165             s->sprite_brightness_change= get_bits1(gb);
4166             if(s->vol_sprite_usage==STATIC_SPRITE)
4167                 s->low_latency_sprite= get_bits1(gb);
4168         }
4169         // FIXME sadct disable bit if verid!=1 && shape not rect
4170
4171         if (get_bits1(gb) == 1) {   /* not_8_bit */
4172             s->quant_precision = get_bits(gb, 4); /* quant_precision */
4173             if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4174             if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4175         } else {
4176             s->quant_precision = 5;
4177         }
4178
4179         // FIXME a bunch of grayscale shape things
4180
4181         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4182             int i, j, v;
4183
4184             /* load default matrixes */
4185             for(i=0; i<64; i++){
4186                 int j= s->idct_permutation[i];
4187                 v= ff_mpeg4_default_intra_matrix[i];
4188                 s->intra_matrix[j]= v;
4189                 s->chroma_intra_matrix[j]= v;
4190
4191                 v= ff_mpeg4_default_non_intra_matrix[i];
4192                 s->inter_matrix[j]= v;
4193                 s->chroma_inter_matrix[j]= v;
4194             }
4195
4196             /* load custom intra matrix */
4197             if(get_bits1(gb)){
4198                 int last=0;
4199                 for(i=0; i<64; i++){
4200                     v= get_bits(gb, 8);
4201                     if(v==0) break;
4202
4203                     last= v;
4204                     j= s->idct_permutation[ ff_zigzag_direct[i] ];
4205                     s->intra_matrix[j]= v;
4206                     s->chroma_intra_matrix[j]= v;
4207                 }
4208
4209                 /* replicate last value */
4210                 for(; i<64; i++){
4211                     j= s->idct_permutation[ ff_zigzag_direct[i] ];
4212                     s->intra_matrix[j]= v;
4213                     s->chroma_intra_matrix[j]= v;
4214                 }
4215             }
4216
4217             /* load custom non intra matrix */
4218             if(get_bits1(gb)){
4219                 int last=0;
4220                 for(i=0; i<64; i++){
4221                     v= get_bits(gb, 8);
4222                     if(v==0) break;
4223
4224                     last= v;
4225                     j= s->idct_permutation[ ff_zigzag_direct[i] ];
4226                     s->inter_matrix[j]= v;
4227                     s->chroma_inter_matrix[j]= v;
4228                 }
4229
4230                 /* replicate last value */
4231                 for(; i<64; i++){
4232                     j= s->idct_permutation[ ff_zigzag_direct[i] ];
4233                     s->inter_matrix[j]= last;
4234                     s->chroma_inter_matrix[j]= last;
4235                 }
4236             }
4237
4238             // FIXME a bunch of grayscale shape things
4239         }
4240
4241         if(vo_ver_id != 1)
4242              s->quarter_sample= get_bits1(gb);
4243         else s->quarter_sample=0;
4244
4245         if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4246
4247         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4248
4249         s->data_partitioning= get_bits1(gb);
4250         if(s->data_partitioning){
4251             s->rvlc= get_bits1(gb);
4252             if(s->rvlc){
4253                 printf("reversible vlc not supported\n");
4254             }
4255         }
4256
4257         if(vo_ver_id != 1) {
4258             s->new_pred= get_bits1(gb);
4259             if(s->new_pred){
4260                 printf("new pred not supported\n");
4261                 skip_bits(gb, 2); /* requested upstream message type */
4262                 skip_bits1(gb); /* newpred segment type */
4263             }
4264             s->reduced_res_vop= get_bits1(gb);
4265             if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4266         }
4267         else{
4268             s->new_pred=0;
4269             s->reduced_res_vop= 0;
4270         }
4271
4272         s->scalability= get_bits1(gb);
4273
4274         if (s->scalability) {
4275             GetBitContext bak= *gb;
4276             int ref_layer_id;
4277             int ref_layer_sampling_dir;
4278             int h_sampling_factor_n;
4279             int h_sampling_factor_m;
4280             int v_sampling_factor_n;
4281             int v_sampling_factor_m;
4282
4283             s->hierachy_type= get_bits1(gb);
4284             ref_layer_id= get_bits(gb, 4);
4285             ref_layer_sampling_dir= get_bits1(gb);
4286             h_sampling_factor_n= get_bits(gb, 5);
4287             h_sampling_factor_m= get_bits(gb, 5);
4288             v_sampling_factor_n= get_bits(gb, 5);
4289             v_sampling_factor_m= get_bits(gb, 5);
4290             s->enhancement_type= get_bits1(gb);
4291
4292             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
4293                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4294
4295 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4296                 s->scalability=0;
4297
4298                 *gb= bak;
4299             }else
4300                 printf("scalability not supported\n");
4301
4302             // bin shape stuff FIXME
4303         }
4304     }
4305     return 0;
4306 }
4307
4308 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4309     char buf[256];
4310     int i;
4311     int e;
4312     int ver, build, ver2, ver3;
4313
4314     buf[0]= show_bits(gb, 8);
4315     for(i=1; i<256; i++){
4316         buf[i]= show_bits(gb, 16)&0xFF;
4317         if(buf[i]==0) break;
4318         skip_bits(gb, 8);
4319     }
4320     buf[255]=0;
4321
4322     /* divx detection */
4323     e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4324     if(e!=2)
4325         e=sscanf(buf, "DivX%db%d", &ver, &build);
4326     if(e==2){
4327         s->divx_version= ver;
4328         s->divx_build= build;
4329         if(s->picture_number==0){
4330             printf("This file was encoded with DivX%d Build%d\n", ver, build);
4331         }
4332     }
4333
4334     /* ffmpeg detection */
4335     e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4336     if(e!=4)
4337         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
4338     if(e!=4){
4339         if(strcmp(buf, "ffmpeg")==0){
4340             s->ffmpeg_version= 0x000406;
4341             s->lavc_build= 4600;
4342         }
4343     }
4344     if(e==4){
4345         s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4346         s->lavc_build= build;
4347         if(s->picture_number==0)
4348             printf("This file was encoded with libavcodec build %d\n", build);
4349     }
4350
4351     /* xvid detection */
4352     e=sscanf(buf, "XviD%d", &build);
4353     if(e==1){
4354         s->xvid_build= build;
4355         if(s->picture_number==0)
4356             printf("This file was encoded with XviD build %d\n", build);
4357     }
4358
4359 //printf("User Data: %s\n", buf);
4360     return 0;
4361 }
4362
4363 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4364     int time_incr, time_increment;
4365
4366     s->pict_type = get_bits(gb, 2) + I_TYPE;    /* pict type: I = 0 , P = 1 */
4367     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4368         printf("low_delay flag set, but shouldnt, clearing it\n");
4369         s->low_delay=0;
4370     }
4371
4372     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4373     if(s->partitioned_frame)
4374         s->decode_mb= mpeg4_decode_partitioned_mb;
4375     else
4376         s->decode_mb= ff_h263_decode_mb;
4377
4378     if(s->time_increment_resolution==0){
4379         s->time_increment_resolution=1;
4380 //        fprintf(stderr, "time_increment_resolution is illegal\n");
4381     }
4382     time_incr=0;
4383     while (get_bits1(gb) != 0)
4384         time_incr++;
4385
4386     check_marker(gb, "before time_increment");
4387     time_increment= get_bits(gb, s->time_increment_bits);
4388 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4389     if(s->pict_type!=B_TYPE){
4390         s->last_time_base= s->time_base;
4391         s->time_base+= time_incr;
4392         s->time= s->time_base*s->time_increment_resolution + time_increment;
4393         if(s->workaround_bugs&FF_BUG_UMP4){
4394             if(s->time < s->last_non_b_time){
4395 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4396                 s->time_base++;
4397                 s->time+= s->time_increment_resolution;
4398             }
4399         }
4400         s->pp_time= s->time - s->last_non_b_time;
4401         s->last_non_b_time= s->time;
4402     }else{
4403         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4404         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4405         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4406 //            printf("messed up order, seeking?, skiping current b frame\n");
4407             return FRAME_SKIPED;
4408         }
4409
4410         if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4411         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4412 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4413         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4414                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4415         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
4416                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4417     }
4418
4419     s->avctx->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4420
4421     if(check_marker(gb, "before vop_coded")==0 && s->picture_number==0){
4422         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4423         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4424             if(get_bits1(gb)) break;
4425         }
4426         printf("my guess is %d bits ;)\n",s->time_increment_bits);
4427     }
4428     /* vop coded */
4429     if (get_bits1(gb) != 1){
4430         printf("vop not coded\n");
4431         return FRAME_SKIPED;
4432     }
4433 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4434 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4435     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4436                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4437         /* rounding type for motion estimation */
4438         s->no_rounding = get_bits1(gb);
4439     } else {
4440         s->no_rounding = 0;
4441     }
4442 //FIXME reduced res stuff
4443
4444      if (s->shape != RECT_SHAPE) {
4445          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4446              int width, height, hor_spat_ref, ver_spat_ref;
4447
4448              width = get_bits(gb, 13);
4449              skip_bits1(gb);   /* marker */
4450              height = get_bits(gb, 13);
4451              skip_bits1(gb);   /* marker */
4452              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4453              skip_bits1(gb);   /* marker */
4454              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4455          }
4456          skip_bits1(gb); /* change_CR_disable */
4457
4458          if (get_bits1(gb) != 0) {
4459              skip_bits(gb, 8); /* constant_alpha_value */
4460          }
4461      }
4462 //FIXME complexity estimation stuff
4463
4464      if (s->shape != BIN_ONLY_SHAPE) {
4465          int t;
4466          t=get_bits(gb, 3); /* intra dc VLC threshold */
4467 //printf("threshold %d\n", t);
4468          if(!s->progressive_sequence){
4469              s->top_field_first= get_bits1(gb);
4470              s->alternate_scan= get_bits1(gb);
4471          }else
4472              s->alternate_scan= 0;
4473      }
4474
4475      if(s->alternate_scan){
4476          ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
4477          ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
4478          ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4479          ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4480      } else{
4481          ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
4482          ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
4483          ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4484          ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4485      }
4486
4487      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4488          mpeg4_decode_sprite_trajectory(s);
4489          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4490          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4491      }
4492
4493      if (s->shape != BIN_ONLY_SHAPE) {
4494          s->qscale = get_bits(gb, s->quant_precision);
4495          if(s->qscale==0){
4496              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4497              return -1; // makes no sense to continue, as there is nothing left from the image then
4498          }
4499
4500          if (s->pict_type != I_TYPE) {
4501              s->f_code = get_bits(gb, 3);       /* fcode_for */
4502              if(s->f_code==0){
4503                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4504                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
4505              }
4506          }else
4507              s->f_code=1;
4508
4509          if (s->pict_type == B_TYPE) {
4510              s->b_code = get_bits(gb, 3);
4511          }else
4512              s->b_code=1;
4513 #if 0
4514 printf("qp:%d fc:%d bc:%d type:%s size:%d pro:%d alt:%d top:%d qpel:%d part:%d resync:%d w:%d a:%d\n",
4515     s->qscale, s->f_code, s->b_code,
4516     s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4517     gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4518     s->quarter_sample, s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4519     s->sprite_warping_accuracy);
4520 #endif
4521          if(!s->scalability){
4522              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4523                  skip_bits1(gb); // vop shape coding type
4524              }
4525          }else{
4526              if(s->enhancement_type){
4527                  int load_backward_shape= get_bits1(gb);
4528                  if(load_backward_shape){
4529                      printf("load backward shape isnt supported\n");
4530                  }
4531              }
4532              skip_bits(gb, 2); //ref_select_code
4533          }
4534      }
4535      /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4536      // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4537      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4538          printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4539          s->low_delay=1;
4540      }
4541
4542      s->picture_number++; // better than pic number==0 allways ;)
4543
4544      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
4545      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4546
4547      if(s->divx_version==0 || s->divx_version < 500){
4548          s->h_edge_pos= s->width;
4549          s->v_edge_pos= s->height;
4550      }
4551      return 0;
4552 }
4553
4554 /**
4555  * decode mpeg4 headers
4556  * @return <0 if no VOP found (or a damaged one)
4557  *         FRAME_SKIPPED if a not coded VOP is found
4558  *         0 if a VOP is found
4559  */
4560 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
4561 {
4562     int startcode, v;
4563
4564     /* search next start code */
4565     align_get_bits(gb);
4566     startcode = 0xff;
4567     for(;;) {
4568         v = get_bits(gb, 8);
4569         startcode = ((startcode << 8) | v) & 0xffffffff;
4570
4571         if(get_bits_count(gb) >= gb->size*8){
4572             if(gb->size==1 && s->divx_version){
4573                 printf("frame skip %d\n", gb->size);
4574                 return FRAME_SKIPED; //divx bug
4575             }else
4576                 return -1; //end of stream
4577         }
4578
4579         if((startcode&0xFFFFFF00) != 0x100)
4580             continue; //no startcode
4581
4582         switch(startcode){
4583         case 0x120:
4584             decode_vol_header(s, gb);
4585             break;
4586         case 0x1b2:
4587             decode_user_data(s, gb);
4588             break;
4589         case 0x1b6:
4590             return decode_vop_header(s, gb);
4591         default:
4592 //            printf("startcode %X found\n", startcode);
4593             break;
4594         }
4595
4596         align_get_bits(gb);
4597         startcode = 0xff;
4598     }
4599 }
4600
4601 /* don't understand why they choose a different header ! */
4602 int intel_h263_decode_picture_header(MpegEncContext *s)
4603 {
4604     int format;
4605
4606     /* picture header */
4607     if (get_bits(&s->gb, 22) != 0x20) {
4608         fprintf(stderr, "Bad picture start code\n");
4609         return -1;
4610     }
4611     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4612
4613     if (get_bits1(&s->gb) != 1) {
4614         fprintf(stderr, "Bad marker\n");
4615         return -1;      /* marker */
4616     }
4617     if (get_bits1(&s->gb) != 0) {
4618         fprintf(stderr, "Bad H263 id\n");
4619         return -1;      /* h263 id */
4620     }
4621     skip_bits1(&s->gb); /* split screen off */
4622     skip_bits1(&s->gb); /* camera  off */
4623     skip_bits1(&s->gb); /* freeze picture release off */
4624
4625     format = get_bits(&s->gb, 3);
4626     if (format != 7) {
4627         fprintf(stderr, "Intel H263 free format not supported\n");
4628         return -1;
4629     }
4630     s->h263_plus = 0;
4631
4632     s->pict_type = I_TYPE + get_bits1(&s->gb);
4633
4634     s->unrestricted_mv = get_bits1(&s->gb);
4635     s->h263_long_vectors = s->unrestricted_mv;
4636
4637     if (get_bits1(&s->gb) != 0) {
4638         fprintf(stderr, "SAC not supported\n");
4639         return -1;      /* SAC: off */
4640     }
4641     if (get_bits1(&s->gb) != 0) {
4642         fprintf(stderr, "Advanced Prediction Mode not supported\n");
4643         return -1;      /* advanced prediction mode: off */
4644     }
4645     if (get_bits1(&s->gb) != 0) {
4646         fprintf(stderr, "PB frame mode no supported\n");
4647         return -1;      /* PB frame mode */
4648     }
4649
4650     /* skip unknown header garbage */
4651     skip_bits(&s->gb, 41);
4652
4653     s->qscale = get_bits(&s->gb, 5);
4654     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4655
4656     /* PEI */
4657     while (get_bits1(&s->gb) != 0) {
4658         skip_bits(&s->gb, 8);
4659     }
4660     s->f_code = 1;
4661
4662     s->y_dc_scale_table=
4663     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4664
4665     return 0;
4666 }
4667