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