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