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, 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 #if 1
1094         val+= l;
1095         val&= 2*l-1;
1096         val-= l;
1097         sign = val>>31;
1098         val= (val^sign)-sign;
1099         sign&=1;
1100 #else
1101         if (val < -l) {
1102             val += 2*l;
1103         } else if (val >= l) {
1104             val -= 2*l;
1105         }
1106
1107         assert(val>=-l && val<l);
1108
1109         if (val >= 0) {
1110             sign = 0;
1111         } else {
1112             val = -val;
1113             sign = 1;
1114         }
1115 #endif
1116         val--;
1117         code = (val >> bit_size) + 1;
1118         bits = val & (range - 1);
1119
1120         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1121         if (bit_size > 0) {
1122             put_bits(&s->pb, bit_size, bits);
1123         }
1124     }
1125 }
1126
1127 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1128 static void h263p_encode_umotion(MpegEncContext * s, int val)
1129 {
1130     short sval = 0;
1131     short i = 0;
1132     short n_bits = 0;
1133     short temp_val;
1134     int code = 0;
1135     int tcode;
1136
1137     if ( val == 0)
1138         put_bits(&s->pb, 1, 1);
1139     else if (val == 1)
1140         put_bits(&s->pb, 3, 0);
1141     else if (val == -1)
1142         put_bits(&s->pb, 3, 2);
1143     else {
1144
1145         sval = ((val < 0) ? (short)(-val):(short)val);
1146         temp_val = sval;
1147
1148         while (temp_val != 0) {
1149             temp_val = temp_val >> 1;
1150             n_bits++;
1151         }
1152
1153         i = n_bits - 1;
1154         while (i > 0) {
1155             tcode = (sval & (1 << (i-1))) >> (i-1);
1156             tcode = (tcode << 1) | 1;
1157             code = (code << 2) | tcode;
1158             i--;
1159         }
1160         code = ((code << 1) | (val < 0)) << 1;
1161         put_bits(&s->pb, (2*n_bits)+1, code);
1162         //printf("\nVal = %d\tCode = %d", sval, code);
1163     }
1164 }
1165
1166 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1167 {
1168     int f_code;
1169     int mv;
1170     for(f_code=1; f_code<=MAX_FCODE; f_code++){
1171         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1172             int len;
1173
1174             if(mv==0) len= mvtab[0][1];
1175             else{
1176                 int val, bit_size, range, code;
1177
1178                 bit_size = s->f_code - 1;
1179                 range = 1 << bit_size;
1180
1181                 val=mv;
1182                 if (val < 0)
1183                     val = -val;
1184                 val--;
1185                 code = (val >> bit_size) + 1;
1186                 if(code<33){
1187                     len= mvtab[code][1] + 1 + bit_size;
1188                 }else{
1189                     len= mvtab[32][1] + 2 + bit_size;
1190                 }
1191             }
1192
1193             mv_penalty[f_code][mv+MAX_MV]= len;
1194         }
1195     }
1196
1197     for(f_code=MAX_FCODE; f_code>0; f_code--){
1198         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1199             fcode_tab[mv+MAX_MV]= f_code;
1200         }
1201     }
1202
1203     for(mv=0; mv<MAX_MV*2+1; mv++){
1204         umv_fcode_tab[mv]= 1;
1205     }
1206 }
1207
1208 static void init_uni_dc_tab(void)
1209 {
1210     int level, uni_code, uni_len;
1211
1212     for(level=-256; level<256; level++){
1213         int size, v, l;
1214         /* find number of bits */
1215         size = 0;
1216         v = abs(level);
1217         while (v) {
1218             v >>= 1;
1219             size++;
1220         }
1221
1222         if (level < 0)
1223             l= (-level) ^ ((1 << size) - 1);
1224         else
1225             l= level;
1226
1227         /* luminance */
1228         uni_code= DCtab_lum[size][0];
1229         uni_len = DCtab_lum[size][1];
1230
1231         if (size > 0) {
1232             uni_code<<=size; uni_code|=l;
1233             uni_len+=size;
1234             if (size > 8){
1235                 uni_code<<=1; uni_code|=1;
1236                 uni_len++;
1237             }
1238         }
1239         uni_DCtab_lum[level+256][0]= uni_code;
1240         uni_DCtab_lum[level+256][1]= uni_len;
1241
1242         /* chrominance */
1243         uni_code= DCtab_chrom[size][0];
1244         uni_len = DCtab_chrom[size][1];
1245
1246         if (size > 0) {
1247             uni_code<<=size; uni_code|=l;
1248             uni_len+=size;
1249             if (size > 8){
1250                 uni_code<<=1; uni_code|=1;
1251                 uni_len++;
1252             }
1253         }
1254         uni_DCtab_chrom[level+256][0]= uni_code;
1255         uni_DCtab_chrom[level+256][1]= uni_len;
1256
1257     }
1258 }
1259
1260 static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1261     int slevel, run, last;
1262
1263     assert(MAX_LEVEL >= 64);
1264     assert(MAX_RUN   >= 63);
1265
1266     for(slevel=-64; slevel<64; slevel++){
1267         if(slevel==0) continue;
1268         for(run=0; run<64; run++){
1269             for(last=0; last<=1; last++){
1270                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1271                 int level= slevel < 0 ? -slevel : slevel;
1272                 int sign= slevel < 0 ? 1 : 0;
1273                 int bits, len, code;
1274                 int level1, run1;
1275
1276                 len_tab[index]= 100;
1277
1278                 /* ESC0 */
1279                 code= get_rl_index(rl, last, run, level);
1280                 bits= rl->table_vlc[code][0];
1281                 len=  rl->table_vlc[code][1];
1282                 bits=bits*2+sign; len++;
1283
1284                 if(code!=rl->n && len < len_tab[index]){
1285                     bits_tab[index]= bits;
1286                     len_tab [index]= len;
1287                 }
1288 #if 1
1289                 /* ESC1 */
1290                 bits= rl->table_vlc[rl->n][0];
1291                 len=  rl->table_vlc[rl->n][1];
1292                 bits=bits*2;    len++; //esc1
1293                 level1= level - rl->max_level[last][run];
1294                 if(level1>0){
1295                     code= get_rl_index(rl, last, run, level1);
1296                     bits<<= rl->table_vlc[code][1];
1297                     len  += rl->table_vlc[code][1];
1298                     bits += rl->table_vlc[code][0];
1299                     bits=bits*2+sign; len++;
1300
1301                     if(code!=rl->n && len < len_tab[index]){
1302                         bits_tab[index]= bits;
1303                         len_tab [index]= len;
1304                     }
1305                 }
1306 #endif
1307 #if 1
1308                 /* ESC2 */
1309                 bits= rl->table_vlc[rl->n][0];
1310                 len=  rl->table_vlc[rl->n][1];
1311                 bits=bits*4+2;    len+=2; //esc2
1312                 run1 = run - rl->max_run[last][level] - 1;
1313                 if(run1>=0){
1314                     code= get_rl_index(rl, last, run1, level);
1315                     bits<<= rl->table_vlc[code][1];
1316                     len  += rl->table_vlc[code][1];
1317                     bits += rl->table_vlc[code][0];
1318                     bits=bits*2+sign; len++;
1319
1320                     if(code!=rl->n && len < len_tab[index]){
1321                         bits_tab[index]= bits;
1322                         len_tab [index]= len;
1323                     }
1324                 }
1325 #endif
1326                 /* ESC3 */
1327                 bits= rl->table_vlc[rl->n][0];
1328                 len = rl->table_vlc[rl->n][1];
1329                 bits=bits*4+3;    len+=2; //esc3
1330                 bits=bits*2+last; len++;
1331                 bits=bits*64+run; len+=6;
1332                 bits=bits*2+1;    len++;  //marker
1333                 bits=bits*4096+(slevel&0xfff); len+=12;
1334                 bits=bits*2+1;    len++;  //marker
1335
1336                 if(len < len_tab[index]){
1337                     bits_tab[index]= bits;
1338                     len_tab [index]= len;
1339                 }
1340             }
1341         }
1342     }
1343 }
1344
1345 void h263_encode_init(MpegEncContext *s)
1346 {
1347     static int done = 0;
1348
1349     if (!done) {
1350         done = 1;
1351
1352         init_uni_dc_tab();
1353
1354         init_rl(&rl_inter);
1355         init_rl(&rl_intra);
1356         init_rl(&rl_intra_aic);
1357
1358         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1359         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1360
1361         init_mv_penalty_and_fcode(s);
1362     }
1363     s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1364
1365     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1366     switch(s->codec_id){
1367     case CODEC_ID_MPEG4:
1368         s->fcode_tab= fcode_tab;
1369         s->min_qcoeff= -2048;
1370         s->max_qcoeff=  2047;
1371         break;
1372     case CODEC_ID_H263P:
1373         s->fcode_tab= umv_fcode_tab;
1374         s->min_qcoeff= -128;
1375         s->max_qcoeff=  127;
1376         break;
1377         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1378     default: //nothing needed default table allready set in mpegvideo.c
1379         s->min_qcoeff= -128;
1380         s->max_qcoeff=  127;
1381         s->y_dc_scale_table=
1382         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1383     }
1384
1385     if(s->mpeg_quant){
1386         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1387         s->inter_quant_bias= 0;
1388     }else{
1389         s->intra_quant_bias=0;
1390         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1391     }
1392 }
1393
1394 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1395 {
1396     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1397     RLTable *rl;
1398
1399     rl = &rl_inter;
1400     if (s->mb_intra && !s->h263_aic) {
1401         /* DC coef */
1402             level = block[0];
1403         /* 255 cannot be represented, so we clamp */
1404         if (level > 254) {
1405             level = 254;
1406             block[0] = 254;
1407         }
1408         /* 0 cannot be represented also */
1409         else if (!level) {
1410             level = 1;
1411             block[0] = 1;
1412         }
1413             if (level == 128)
1414                 put_bits(&s->pb, 8, 0xff);
1415             else
1416                 put_bits(&s->pb, 8, level & 0xff);
1417             i = 1;
1418     } else {
1419             i = 0;
1420             if (s->h263_aic && s->mb_intra)
1421                 rl = &rl_intra_aic;
1422     }
1423
1424     /* AC coefs */
1425     last_index = s->block_last_index[n];
1426     last_non_zero = i - 1;
1427     for (; i <= last_index; i++) {
1428         j = zigzag_direct[i];
1429         level = block[j];
1430         if (level) {
1431             run = i - last_non_zero - 1;
1432             last = (i == last_index);
1433             sign = 0;
1434             slevel = level;
1435             if (level < 0) {
1436                 sign = 1;
1437                 level = -level;
1438             }
1439             code = get_rl_index(rl, last, run, level);
1440             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1441             if (code == rl->n) {
1442                 put_bits(&s->pb, 1, last);
1443                 put_bits(&s->pb, 6, run);
1444                 put_bits(&s->pb, 8, slevel & 0xff);
1445             } else {
1446                 put_bits(&s->pb, 1, sign);
1447             }
1448                 last_non_zero = i;
1449             }
1450     }
1451 }
1452
1453 /***************************************************/
1454
1455 void ff_mpeg4_stuffing(PutBitContext * pbc)
1456 {
1457     int length;
1458     put_bits(pbc, 1, 0);
1459     length= (-get_bit_count(pbc))&7;
1460     if(length) put_bits(pbc, length, (1<<length)-1);
1461 }
1462
1463 /* must be called before writing the header */
1464 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1465     int time_div, time_mod;
1466
1467     if(s->pict_type==I_TYPE){ //we will encode a vol header
1468         s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1469         if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1470
1471         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1472     }
1473
1474     if(s->avctx->pts)
1475         s->time= (s->avctx->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1476     else
1477         s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1478     time_div= s->time/s->time_increment_resolution;
1479     time_mod= s->time%s->time_increment_resolution;
1480
1481     if(s->pict_type==B_TYPE){
1482         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1483     }else{
1484         s->last_time_base= s->time_base;
1485         s->time_base= time_div;
1486         s->pp_time= s->time - s->last_non_b_time;
1487         s->last_non_b_time= s->time;
1488     }
1489 }
1490
1491 static void mpeg4_encode_vol_header(MpegEncContext * s)
1492 {
1493     int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1494     char buf[255];
1495
1496     s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1497
1498     put_bits(&s->pb, 16, 0);
1499     put_bits(&s->pb, 16, 0x100);        /* video obj */
1500     put_bits(&s->pb, 16, 0);
1501     put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1502
1503     put_bits(&s->pb, 1, 0);             /* random access vol */
1504     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
1505     put_bits(&s->pb, 1, 1);             /* is obj layer id= yes */
1506       put_bits(&s->pb, 4, vo_ver_id);   /* is obj layer ver id */
1507       put_bits(&s->pb, 3, 1);           /* is obj layer priority */
1508     if(s->aspect_ratio_info)
1509         put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1510     else
1511         put_bits(&s->pb, 4, 1);         /* aspect ratio info= sqare pixel */
1512     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1513     {
1514         put_bits(&s->pb, 8, s->aspected_width);
1515         put_bits(&s->pb, 8, s->aspected_height);
1516     }
1517
1518     if(s->low_delay){
1519         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
1520         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
1521         put_bits(&s->pb, 1, s->low_delay);
1522         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
1523     }else{
1524         put_bits(&s->pb, 1, 0);         /* vol control parameters= no */
1525     }
1526
1527     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
1528     put_bits(&s->pb, 1, 1);             /* marker bit */
1529
1530     put_bits(&s->pb, 16, s->time_increment_resolution);
1531     if (s->time_increment_bits < 1)
1532         s->time_increment_bits = 1;
1533     put_bits(&s->pb, 1, 1);             /* marker bit */
1534     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
1535     put_bits(&s->pb, 1, 1);             /* marker bit */
1536     put_bits(&s->pb, 13, s->width);     /* vol width */
1537     put_bits(&s->pb, 1, 1);             /* marker bit */
1538     put_bits(&s->pb, 13, s->height);    /* vol height */
1539     put_bits(&s->pb, 1, 1);             /* marker bit */
1540     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1541     put_bits(&s->pb, 1, 1);             /* obmc disable */
1542     if (vo_ver_id == 1) {
1543         put_bits(&s->pb, 1, s->vol_sprite_usage=0);             /* sprite enable */
1544     }else{ /* vo_ver_id == 2 */
1545         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
1546     }
1547     put_bits(&s->pb, 1, 0);             /* not 8 bit */
1548     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1549     if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1550
1551     if (vo_ver_id != 1)
1552         put_bits(&s->pb, 1, s->quarter_sample=0);
1553     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
1554     s->resync_marker= s->rtp_mode;
1555     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1556     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1557     if(s->data_partitioning){
1558         put_bits(&s->pb, 1, 0);         /* no rvlc */
1559     }
1560
1561     if (vo_ver_id != 1){
1562         put_bits(&s->pb, 1, 0);         /* newpred */
1563         put_bits(&s->pb, 1, 0);         /* reduced res vop */
1564     }
1565     put_bits(&s->pb, 1, 0);             /* scalability */
1566
1567     ff_mpeg4_stuffing(&s->pb);
1568
1569     /* user data */
1570     if(!ff_bit_exact){
1571         put_bits(&s->pb, 16, 0);
1572         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
1573         sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1574         put_string(&s->pb, buf);
1575         ff_mpeg4_stuffing(&s->pb);
1576     }
1577 }
1578
1579 /* write mpeg4 VOP header */
1580 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1581 {
1582     int time_incr;
1583     int time_div, time_mod;
1584
1585     if(s->pict_type==I_TYPE){
1586         s->no_rounding=0;
1587         if(picture_number==0 || !s->strict_std_compliance)
1588             mpeg4_encode_vol_header(s);
1589     }
1590
1591 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1592
1593     put_bits(&s->pb, 16, 0);            /* vop header */
1594     put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1595     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
1596
1597     time_div= s->time/s->time_increment_resolution;
1598     time_mod= s->time%s->time_increment_resolution;
1599     time_incr= time_div - s->last_time_base;
1600     while(time_incr--)
1601         put_bits(&s->pb, 1, 1);
1602
1603     put_bits(&s->pb, 1, 0);
1604
1605     put_bits(&s->pb, 1, 1);     /* marker */
1606     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1607     put_bits(&s->pb, 1, 1);     /* marker */
1608     put_bits(&s->pb, 1, 1);     /* vop coded */
1609     if (    s->pict_type == P_TYPE
1610         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1611         s->no_rounding ^= 1;
1612         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
1613     }
1614     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
1615     if(!s->progressive_sequence){
1616          put_bits(&s->pb, 1, s->top_field_first);
1617          put_bits(&s->pb, 1, s->alternate_scan);
1618     }
1619     //FIXME sprite stuff
1620
1621     put_bits(&s->pb, 5, s->qscale);
1622
1623     if (s->pict_type != I_TYPE)
1624         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1625     if (s->pict_type == B_TYPE)
1626         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1627     //    printf("****frame %d\n", picture_number);
1628
1629      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1630      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1631      s->h_edge_pos= s->width;
1632      s->v_edge_pos= s->height;
1633 }
1634
1635 static void change_qscale(MpegEncContext * s, int dquant)
1636 {
1637     s->qscale += dquant;
1638
1639     if (s->qscale < 1)
1640         s->qscale = 1;
1641     else if (s->qscale > 31)
1642         s->qscale = 31;
1643
1644     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1645     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1646 }
1647
1648 inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1649 {
1650     int a, b, c, wrap, pred, scale;
1651     UINT16 *dc_val;
1652     int dummy;
1653
1654     /* find prediction */
1655     if (n < 4) {
1656         scale = s->y_dc_scale;
1657     } else {
1658         scale = s->c_dc_scale;
1659     }
1660     wrap= s->block_wrap[n];
1661     dc_val = s->dc_val[0] + s->block_index[n];
1662
1663     /* B C
1664      * A X
1665      */
1666     a = dc_val[ - 1];
1667     b = dc_val[ - 1 - wrap];
1668     c = dc_val[ - wrap];
1669
1670     if (abs(a - b) < abs(b - c)) {
1671         pred = c;
1672         *dir_ptr = 1; /* top */
1673     } else {
1674         pred = a;
1675         *dir_ptr = 0; /* left */
1676     }
1677     /* we assume pred is positive */
1678 #ifdef ARCH_X86
1679         asm volatile (
1680                 "xorl %%edx, %%edx      \n\t"
1681                 "mul %%ecx              \n\t"
1682                 : "=d" (pred), "=a"(dummy)
1683                 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1684         );
1685 #else
1686     pred = (pred + (scale >> 1)) / scale;
1687 #endif
1688
1689     /* prepare address for prediction update */
1690     *dc_val_ptr = &dc_val[0];
1691
1692     return pred;
1693 }
1694
1695 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1696                    int dir)
1697 {
1698     int i;
1699     INT16 *ac_val, *ac_val1;
1700
1701     /* find prediction */
1702     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1703     ac_val1 = ac_val;
1704     if (s->ac_pred) {
1705         if (dir == 0) {
1706             const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1707             /* left prediction */
1708             ac_val -= 16;
1709
1710             if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1711                 /* same qscale */
1712                 for(i=1;i<8;i++) {
1713                     block[block_permute_op(i*8)] += ac_val[i];
1714                 }
1715             }else{
1716                 /* different qscale, we must rescale */
1717                 for(i=1;i<8;i++) {
1718                     block[block_permute_op(i*8)] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1719                 }
1720             }
1721         } else {
1722             const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1723             /* top prediction */
1724             ac_val -= 16 * s->block_wrap[n];
1725
1726             if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1727                 /* same qscale */
1728                 for(i=1;i<8;i++) {
1729                     block[block_permute_op(i)] += ac_val[i + 8];
1730                 }
1731             }else{
1732                 /* different qscale, we must rescale */
1733                 for(i=1;i<8;i++) {
1734                     block[block_permute_op(i)] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1735                 }
1736             }
1737         }
1738     }
1739     /* left copy */
1740     for(i=1;i<8;i++)
1741         ac_val1[i] = block[block_permute_op(i * 8)];
1742
1743     /* top copy */
1744     for(i=1;i<8;i++)
1745         ac_val1[8 + i] = block[block_permute_op(i)];
1746
1747 }
1748
1749 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1750                               int dir)
1751 {
1752     int i;
1753     INT16 *ac_val;
1754
1755     /* find prediction */
1756     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1757
1758     if (dir == 0) {
1759         const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1760         /* left prediction */
1761         ac_val -= 16;
1762         if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1763             /* same qscale */
1764             for(i=1;i<8;i++) {
1765                 block[block_permute_op(i*8)] -= ac_val[i];
1766             }
1767         }else{
1768             /* different qscale, we must rescale */
1769             for(i=1;i<8;i++) {
1770                 block[block_permute_op(i*8)] -= ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1771             }
1772         }
1773     } else {
1774         const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1775         /* top prediction */
1776         ac_val -= 16 * s->block_wrap[n];
1777         if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1778             /* same qscale */
1779             for(i=1;i<8;i++) {
1780                 block[block_permute_op(i)] -= ac_val[i + 8];
1781             }
1782         }else{
1783             /* different qscale, we must rescale */
1784             for(i=1;i<8;i++) {
1785                 block[block_permute_op(i)] -= ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1786             }
1787         }
1788     }
1789 }
1790
1791 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1792 {
1793 #if 1
1794 //    if(level<-255 || level>255) printf("dc overflow\n");
1795     level+=256;
1796     if (n < 4) {
1797         /* luminance */
1798         put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1799     } else {
1800         /* chrominance */
1801         put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1802     }
1803 #else
1804     int size, v;
1805     /* find number of bits */
1806     size = 0;
1807     v = abs(level);
1808     while (v) {
1809         v >>= 1;
1810         size++;
1811     }
1812
1813     if (n < 4) {
1814         /* luminance */
1815         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1816     } else {
1817         /* chrominance */
1818         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1819     }
1820
1821     /* encode remaining bits */
1822     if (size > 0) {
1823         if (level < 0)
1824             level = (-level) ^ ((1 << size) - 1);
1825         put_bits(&s->pb, size, level);
1826         if (size > 8)
1827             put_bits(&s->pb, 1, 1);
1828     }
1829 #endif
1830 }
1831
1832 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1833                                UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1834 {
1835     int last, i, last_non_zero, sign;
1836     int code;
1837     const RLTable *rl;
1838     UINT32 *bits_tab;
1839     UINT8 *len_tab;
1840     const int last_index = s->block_last_index[n];
1841
1842     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
1843         /* mpeg4 based DC predictor */
1844         mpeg4_encode_dc(dc_pb, intra_dc, n);
1845         if(last_index<1) return;
1846         i = 1;
1847         rl = &rl_intra;
1848         bits_tab= uni_mpeg4_intra_rl_bits;
1849         len_tab = uni_mpeg4_intra_rl_len;
1850     } else {
1851         if(last_index<0) return;
1852         i = 0;
1853         rl = &rl_inter;
1854         bits_tab= uni_mpeg4_inter_rl_bits;
1855         len_tab = uni_mpeg4_inter_rl_len;
1856     }
1857
1858     /* AC coefs */
1859     last_non_zero = i - 1;
1860 #if 1
1861     for (; i < last_index; i++) {
1862         int level = block[ scan_table[i] ];
1863         if (level) {
1864             int run = i - last_non_zero - 1;
1865             level+=64;
1866             if((level&(~127)) == 0){
1867                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
1868                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
1869             }else{ //ESC3
1870                 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);
1871             }
1872             last_non_zero = i;
1873         }
1874     }
1875     /*if(i<=last_index)*/{
1876         int level = block[ scan_table[i] ];
1877         int run = i - last_non_zero - 1;
1878         level+=64;
1879         if((level&(~127)) == 0){
1880             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
1881             put_bits(ac_pb, len_tab[index], bits_tab[index]);
1882         }else{ //ESC3
1883             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);
1884         }
1885     }
1886 #else
1887     for (; i <= last_index; i++) {
1888         const int slevel = block[ scan_table[i] ];
1889         if (slevel) {
1890             int level;
1891             int run = i - last_non_zero - 1;
1892             last = (i == last_index);
1893             sign = 0;
1894             level = slevel;
1895             if (level < 0) {
1896                 sign = 1;
1897                 level = -level;
1898             }
1899             code = get_rl_index(rl, last, run, level);
1900             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1901             if (code == rl->n) {
1902                 int level1, run1;
1903                 level1 = level - rl->max_level[last][run];
1904                 if (level1 < 1)
1905                     goto esc2;
1906                 code = get_rl_index(rl, last, run, level1);
1907                 if (code == rl->n) {
1908                 esc2:
1909                     put_bits(ac_pb, 1, 1);
1910                     if (level > MAX_LEVEL)
1911                         goto esc3;
1912                     run1 = run - rl->max_run[last][level] - 1;
1913                     if (run1 < 0)
1914                         goto esc3;
1915                     code = get_rl_index(rl, last, run1, level);
1916                     if (code == rl->n) {
1917                     esc3:
1918                         /* third escape */
1919                         put_bits(ac_pb, 1, 1);
1920                         put_bits(ac_pb, 1, last);
1921                         put_bits(ac_pb, 6, run);
1922                         put_bits(ac_pb, 1, 1);
1923                         put_bits(ac_pb, 12, slevel & 0xfff);
1924                         put_bits(ac_pb, 1, 1);
1925                     } else {
1926                         /* second escape */
1927                         put_bits(ac_pb, 1, 0);
1928                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1929                         put_bits(ac_pb, 1, sign);
1930                     }
1931                 } else {
1932                     /* first escape */
1933                     put_bits(ac_pb, 1, 0);
1934                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1935                     put_bits(ac_pb, 1, sign);
1936                 }
1937             } else {
1938                 put_bits(ac_pb, 1, sign);
1939             }
1940             last_non_zero = i;
1941         }
1942     }
1943 #endif
1944 }
1945
1946
1947
1948 /***********************************************/
1949 /* decoding */
1950
1951 static VLC intra_MCBPC_vlc;
1952 static VLC inter_MCBPC_vlc;
1953 static VLC cbpy_vlc;
1954 static VLC mv_vlc;
1955 static VLC dc_lum, dc_chrom;
1956 static VLC sprite_trajectory;
1957 static VLC mb_type_b_vlc;
1958
1959 void init_rl(RLTable *rl)
1960 {
1961     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1962     UINT8 index_run[MAX_RUN+1];
1963     int last, run, level, start, end, i;
1964
1965     /* compute max_level[], max_run[] and index_run[] */
1966     for(last=0;last<2;last++) {
1967         if (last == 0) {
1968             start = 0;
1969             end = rl->last;
1970         } else {
1971             start = rl->last;
1972             end = rl->n;
1973         }
1974
1975         memset(max_level, 0, MAX_RUN + 1);
1976         memset(max_run, 0, MAX_LEVEL + 1);
1977         memset(index_run, rl->n, MAX_RUN + 1);
1978         for(i=start;i<end;i++) {
1979             run = rl->table_run[i];
1980             level = rl->table_level[i];
1981             if (index_run[run] == rl->n)
1982                 index_run[run] = i;
1983             if (level > max_level[run])
1984                 max_level[run] = level;
1985             if (run > max_run[level])
1986                 max_run[level] = run;
1987         }
1988         rl->max_level[last] = av_malloc(MAX_RUN + 1);
1989         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1990         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1991         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1992         rl->index_run[last] = av_malloc(MAX_RUN + 1);
1993         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1994     }
1995 }
1996
1997 void init_vlc_rl(RLTable *rl)
1998 {
1999     int i, q;
2000
2001     init_vlc(&rl->vlc, 9, rl->n + 1,
2002              &rl->table_vlc[0][1], 4, 2,
2003              &rl->table_vlc[0][0], 4, 2);
2004
2005
2006     for(q=0; q<32; q++){
2007         int qmul= q*2;
2008         int qadd= (q-1)|1;
2009
2010         if(q==0){
2011             qmul=1;
2012             qadd=0;
2013         }
2014
2015         rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2016         for(i=0; i<rl->vlc.table_size; i++){
2017             int code= rl->vlc.table[i][0];
2018             int len = rl->vlc.table[i][1];
2019             int level, run;
2020
2021             if(len==0){ // illegal code
2022                 run= 66;
2023                 level= MAX_LEVEL;
2024             }else if(len<0){ //more bits needed
2025                 run= 0;
2026                 level= code;
2027             }else{
2028                 if(code==rl->n){ //esc
2029                     run= 66;
2030                     level= 0;
2031                 }else{
2032                     run=   rl->table_run  [code] + 1;
2033                     level= rl->table_level[code] * qmul + qadd;
2034                     if(code >= rl->last) run+=192;
2035                 }
2036             }
2037             rl->rl_vlc[q][i].len= len;
2038             rl->rl_vlc[q][i].level= level;
2039             rl->rl_vlc[q][i].run= run;
2040         }
2041     }
2042 }
2043
2044 /* init vlcs */
2045
2046 /* XXX: find a better solution to handle static init */
2047 void h263_decode_init_vlc(MpegEncContext *s)
2048 {
2049     static int done = 0;
2050
2051     if (!done) {
2052         done = 1;
2053
2054         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
2055                  intra_MCBPC_bits, 1, 1,
2056                  intra_MCBPC_code, 1, 1);
2057         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
2058                  inter_MCBPC_bits, 1, 1,
2059                  inter_MCBPC_code, 1, 1);
2060         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2061                  &cbpy_tab[0][1], 2, 1,
2062                  &cbpy_tab[0][0], 2, 1);
2063         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2064                  &mvtab[0][1], 2, 1,
2065                  &mvtab[0][0], 2, 1);
2066         init_rl(&rl_inter);
2067         init_rl(&rl_intra);
2068         init_rl(&rl_intra_aic);
2069         init_vlc_rl(&rl_inter);
2070         init_vlc_rl(&rl_intra);
2071         init_vlc_rl(&rl_intra_aic);
2072         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2073                  &DCtab_lum[0][1], 2, 1,
2074                  &DCtab_lum[0][0], 2, 1);
2075         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2076                  &DCtab_chrom[0][1], 2, 1,
2077                  &DCtab_chrom[0][0], 2, 1);
2078         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2079                  &sprite_trajectory_tab[0][1], 4, 2,
2080                  &sprite_trajectory_tab[0][0], 4, 2);
2081         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2082                  &mb_type_b_tab[0][1], 2, 1,
2083                  &mb_type_b_tab[0][0], 2, 1);
2084     }
2085
2086     s->progressive_sequence=1; // set to most likely for the case of incomplete headers
2087 }
2088
2089 int h263_decode_gob_header(MpegEncContext *s)
2090 {
2091     unsigned int val, gfid;
2092
2093     /* Check for GOB Start Code */
2094     val = show_bits(&s->gb, 16);
2095     if (val == 0) {
2096         /* We have a GBSC probably with GSTUFF */
2097         skip_bits(&s->gb, 16); /* Drop the zeros */
2098         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
2099 #ifdef DEBUG
2100         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2101 #endif
2102         s->gob_number = get_bits(&s->gb, 5); /* GN */
2103         gfid = get_bits(&s->gb, 2); /* GFID */
2104         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2105 #ifdef DEBUG
2106         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2107 #endif
2108         return 1;
2109     }
2110     return 0;
2111
2112 }
2113
2114 static inline void memsetw(short *tab, int val, int n)
2115 {
2116     int i;
2117     for(i=0;i<n;i++)
2118         tab[i] = val;
2119 }
2120
2121 void ff_mpeg4_init_partitions(MpegEncContext *s)
2122 {
2123     init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2124     init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE, NULL, NULL);
2125 }
2126
2127 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2128 {
2129     const int pb2_len   = get_bit_count(&s->pb2   );
2130     const int tex_pb_len= get_bit_count(&s->tex_pb);
2131     const int bits= get_bit_count(&s->pb);
2132
2133     if(s->pict_type==I_TYPE){
2134         put_bits(&s->pb, 19, DC_MARKER);
2135         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2136         s->i_tex_bits+= tex_pb_len;
2137     }else{
2138         put_bits(&s->pb, 17, MOTION_MARKER);
2139         s->misc_bits+=17 + pb2_len;;
2140         s->mv_bits+= bits - s->last_bits;
2141         s->p_tex_bits+= tex_pb_len;
2142     }
2143
2144     flush_put_bits(&s->pb2);
2145     flush_put_bits(&s->tex_pb);
2146
2147     ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2148     ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2149     s->last_bits= get_bit_count(&s->pb);
2150 }
2151
2152 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2153 {
2154     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2155
2156     ff_mpeg4_stuffing(&s->pb);
2157     if(s->pict_type==I_TYPE)
2158         put_bits(&s->pb, 16, 0);
2159     else if(s->pict_type==B_TYPE)
2160         put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
2161     else /* S/P_TYPE */
2162         put_bits(&s->pb, s->f_code+15, 0);
2163     put_bits(&s->pb, 1, 1);
2164
2165     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2166     put_bits(&s->pb, 5, s->qscale);
2167     put_bits(&s->pb, 1, 0); /* no HEC */
2168 }
2169
2170 /**
2171  * decodes the next video packet and sets s->next_qscale
2172  * returns mb_num of the next packet or <0 if something went wrong
2173  */
2174 static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
2175 {
2176     int bits;
2177     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2178     int header_extension=0, mb_num;
2179 //printf("%X\n", show_bits(&gb, 24));
2180 //printf("parse_video_packet_header\n");
2181 //    if(show_aligned_bits(gb, 1, 16) != 0) return -1;
2182
2183     /* is there enough space left for a video packet + header */
2184     if( get_bits_count(gb) > gb->size*8-20) return -1;
2185
2186 //printf("resync at %d %d\n", s->mb_x, s->mb_y);
2187 //    skip_bits(gb, 1);
2188 //    align_get_bits(gb);
2189     if(get_bits(gb, 16)!=0){
2190         printf("internal error while decoding video packet header\n");
2191     }
2192
2193 //printf("%X\n", show_bits(gb, 24));
2194     bits=0;
2195     while(!get_bits1(gb) && bits<30) bits++;
2196     if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
2197         printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n",
2198                bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
2199         return -1;
2200     }else if(s->pict_type == I_TYPE && bits != 0){
2201         printf("marker too long\n");
2202         return -1;
2203     }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
2204         printf("marker does not match f/b_code\n");
2205         return -1;
2206     }
2207 //printf("%X\n", show_bits(gb, 24));
2208
2209     if(s->shape != RECT_SHAPE){
2210         header_extension= get_bits1(gb);
2211         //FIXME more stuff here
2212     }
2213
2214     mb_num= get_bits(gb, mb_num_bits);
2215     if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
2216         fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
2217         return -1;
2218     }
2219
2220     if(s->shape != BIN_ONLY_SHAPE){
2221         s->next_resync_qscale= get_bits(gb, 5);
2222         if(s->next_resync_qscale==0)
2223             s->next_resync_qscale= s->qscale;
2224         if(s->next_resync_qscale==0){
2225             fprintf(stderr, "qscale==0\n");
2226             return -1;
2227         }
2228     }
2229
2230     if(s->shape == RECT_SHAPE){
2231         header_extension= get_bits1(gb);
2232     }
2233     if(header_extension){
2234         int time_increment;
2235         int time_incr=0;
2236
2237         while (get_bits1(gb) != 0)
2238             time_incr++;
2239
2240         check_marker(gb, "before time_increment in video packed header");
2241         time_increment= get_bits(gb, s->time_increment_bits);
2242         check_marker(gb, "before vop_coding_type in video packed header");
2243
2244         skip_bits(gb, 2); /* vop coding type */
2245         //FIXME not rect stuff here
2246
2247         if(s->shape != BIN_ONLY_SHAPE){
2248             skip_bits(gb, 3); /* intra dc vlc threshold */
2249
2250             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
2251                 mpeg4_decode_sprite_trajectory(s);
2252                 fprintf(stderr, "untested\n");
2253             }
2254
2255             //FIXME reduced res stuff here
2256
2257             if (s->pict_type != I_TYPE) {
2258                 int f_code = get_bits(gb, 3);   /* fcode_for */
2259                 if(f_code==0){
2260                     printf("Error, video packet header damaged (f_code=0)\n");
2261                 }
2262             }
2263             if (s->pict_type == B_TYPE) {
2264                 int b_code = get_bits(gb, 3);
2265                 if(b_code==0){
2266                     printf("Error, video packet header damaged (b_code=0)\n");
2267                 }
2268             }
2269         }
2270     }
2271     //FIXME new-pred stuff
2272
2273 //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));
2274
2275     return mb_num;
2276 }
2277
2278 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2279 {
2280     int c_wrap, c_xy, l_wrap, l_xy;
2281
2282     l_wrap= s->block_wrap[0];
2283     l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2284     c_wrap= s->block_wrap[4];
2285     c_xy= s->mb_y*c_wrap + s->mb_x;
2286
2287     /* clean DC */
2288     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2289     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2290     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2291
2292     /* clean AC */
2293     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2294     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2295     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
2296
2297     /* clean MV */
2298     // we cant clear the MVs as they might be needed by a b frame
2299 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2300 //    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2301     s->last_mv[0][0][0]=
2302     s->last_mv[0][0][1]=
2303     s->last_mv[1][0][0]=
2304     s->last_mv[1][0][1]= 0;
2305 }
2306
2307 /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
2308 int ff_mpeg4_resync(MpegEncContext *s)
2309 {
2310     GetBitContext gb;
2311
2312     /* search & parse next resync marker */
2313
2314     gb= s->next_resync_gb;
2315     align_get_bits(&gb);
2316 //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
2317     for(;;) {
2318         int v= show_bits(&gb, 24);
2319         if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
2320             s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
2321 //printf("mpeg4_resync end\n");
2322             s->gb= s->next_resync_gb; //continue at the next resync marker
2323             return -1;
2324         }else if(v>>8 == 0){
2325             int next;
2326             s->next_resync_pos= get_bits_count(&gb);
2327
2328             next= decode_video_packet_header(s, &gb);
2329             if(next >= 0){
2330                 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
2331                 break;
2332             }
2333
2334             align_get_bits(&gb);
2335         }
2336         skip_bits(&gb, 8);
2337     }
2338     s->next_resync_gb=gb;
2339
2340     return 0;
2341 }
2342
2343 static inline void init_block_index(MpegEncContext *s)
2344 {
2345     s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2346     s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
2347     s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2348     s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
2349     s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2350     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;
2351 }
2352
2353 static inline void update_block_index(MpegEncContext *s)
2354 {
2355     s->block_index[0]+=2;
2356     s->block_index[1]+=2;
2357     s->block_index[2]+=2;
2358     s->block_index[3]+=2;
2359     s->block_index[4]++;
2360     s->block_index[5]++;
2361 }
2362
2363 /**
2364  * decodes the first & second partition
2365  * returns error type or 0 if no error
2366  */
2367 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2368 {
2369     static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2370     int mb_num;
2371
2372     /* decode first partition */
2373     mb_num=0;
2374     s->first_slice_line=1;
2375     s->mb_x= s->resync_mb_x;
2376     for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2377         init_block_index(s);
2378         for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2379             const int xy= s->mb_x + s->mb_y*s->mb_width;
2380             int cbpc;
2381             int dir=0;
2382
2383             mb_num++;
2384             update_block_index(s);
2385             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2386                 s->first_slice_line=0;
2387
2388             if(s->mb_x==0) PRINT_MB_TYPE("\n");
2389
2390             if(s->pict_type==I_TYPE){
2391                 int i;
2392
2393                 PRINT_MB_TYPE("I");
2394                 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2395                 if (cbpc < 0){
2396                     fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2397                     return DECODING_DESYNC;
2398                 }
2399                 s->cbp_table[xy]= cbpc & 3;
2400                 s->mb_type[xy]= MB_TYPE_INTRA;
2401                 s->mb_intra = 1;
2402
2403                 if(cbpc & 4) {
2404                     change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2405                 }
2406                 s->qscale_table[xy]= s->qscale;
2407
2408                 s->mbintra_table[xy]= 1;
2409                 for(i=0; i<6; i++){
2410                     int dc_pred_dir;
2411                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2412                     if(dc < 0){
2413                         fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2414                         return DECODING_DESYNC;
2415                     }
2416                     dir<<=1;
2417                     if(dc_pred_dir) dir|=1;
2418                 }
2419                 s->pred_dir_table[xy]= dir;
2420             }else{ /* P/S_TYPE */
2421                 int mx, my, pred_x, pred_y;
2422                 INT16 * const mot_val= s->motion_val[s->block_index[0]];
2423                 const int stride= s->block_wrap[0]*2;
2424
2425                 if(get_bits1(&s->gb)){
2426                     /* skip mb */
2427                     s->mb_type[xy]= MB_TYPE_SKIPED;
2428                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2429                         const int a= s->sprite_warping_accuracy;
2430                         PRINT_MB_TYPE("G");
2431                         if(s->divx_version==500 && s->divx_build==413){
2432                             mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2433                             my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2434                         }else{
2435                             mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2436                             my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2437                             s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
2438                         }
2439                     }else{
2440                         PRINT_MB_TYPE("S");
2441                         mx = 0;
2442                         my = 0;
2443                     }
2444                     mot_val[0       ]= mot_val[2       ]=
2445                     mot_val[0+stride]= mot_val[2+stride]= mx;
2446                     mot_val[1       ]= mot_val[3       ]=
2447                     mot_val[1+stride]= mot_val[3+stride]= my;
2448
2449                     if(s->mbintra_table[xy])
2450                         ff_clean_intra_table_entries(s);
2451
2452                     continue;
2453                 }
2454                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2455                 if (cbpc < 0){
2456                     fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2457                     return DECODING_DESYNC;
2458                 }
2459                 if (cbpc > 20)
2460                     cbpc+=3;
2461                 else if (cbpc == 20)
2462                     fprintf(stderr, "Stuffing !");
2463                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2464
2465                 s->mb_intra = ((cbpc & 4) != 0);
2466
2467                 if(s->mb_intra){
2468                     PRINT_MB_TYPE("I");
2469                     s->mbintra_table[xy]= 1;
2470                     s->mb_type[xy]= MB_TYPE_INTRA;
2471                     mot_val[0       ]= mot_val[2       ]=
2472                     mot_val[0+stride]= mot_val[2+stride]= 0;
2473                     mot_val[1       ]= mot_val[3       ]=
2474                     mot_val[1+stride]= mot_val[3+stride]= 0;
2475                 }else{
2476                     if(s->mbintra_table[xy])
2477                         ff_clean_intra_table_entries(s);
2478
2479                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2480                         s->mcsel= get_bits1(&s->gb);
2481                     else s->mcsel= 0;
2482
2483                     if ((cbpc & 16) == 0) {
2484                         PRINT_MB_TYPE("P");
2485                         /* 16x16 motion prediction */
2486                         s->mb_type[xy]= MB_TYPE_INTER;
2487
2488                         h263_pred_motion(s, 0, &pred_x, &pred_y);
2489                         if(!s->mcsel)
2490                            mx = h263_decode_motion(s, pred_x, s->f_code);
2491                         else {
2492                             const int a= s->sprite_warping_accuracy;
2493                             if(s->divx_version==500 && s->divx_build==413){
2494                                 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2495                             }else{
2496                                 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2497                             }
2498                         }
2499                         if (mx >= 0xffff)
2500                             return DECODING_DESYNC;
2501
2502                         if(!s->mcsel)
2503                            my = h263_decode_motion(s, pred_y, s->f_code);
2504                         else{
2505                            const int a= s->sprite_warping_accuracy;
2506                             if(s->divx_version==500 && s->divx_build==413){
2507                                 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2508                             }else{
2509                                 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2510                             }
2511                         }
2512                         if (my >= 0xffff)
2513                             return DECODING_DESYNC;
2514                         mot_val[0       ]= mot_val[2       ] =
2515                         mot_val[0+stride]= mot_val[2+stride]= mx;
2516                         mot_val[1       ]= mot_val[3       ]=
2517                         mot_val[1+stride]= mot_val[3+stride]= my;
2518                     } else {
2519                         int i;
2520                         PRINT_MB_TYPE("4");
2521                         s->mb_type[xy]= MB_TYPE_INTER4V;
2522                         for(i=0;i<4;i++) {
2523                             INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2524                             mx = h263_decode_motion(s, pred_x, s->f_code);
2525                             if (mx >= 0xffff)
2526                                 return DECODING_DESYNC;
2527
2528                             my = h263_decode_motion(s, pred_y, s->f_code);
2529                             if (my >= 0xffff)
2530                                 return DECODING_DESYNC;
2531                             mot_val[0] = mx;
2532                             mot_val[1] = my;
2533                         }
2534                     }
2535                 }
2536             }
2537         }
2538         s->mb_x= 0;
2539     }
2540
2541     if     (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER    ) s->decoding_error= DECODING_DESYNC;
2542     else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
2543     if(s->decoding_error== DECODING_DESYNC){
2544         fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
2545         return DECODING_DESYNC;
2546     }
2547
2548     /* decode second partition */
2549     mb_num=0;
2550     s->mb_x= s->resync_mb_x;
2551     for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2552         init_block_index(s);
2553         for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2554             const int xy= s->mb_x + s->mb_y*s->mb_width;
2555
2556             mb_num++;
2557             update_block_index(s);
2558
2559             if(s->pict_type==I_TYPE){
2560                 int ac_pred= get_bits1(&s->gb);
2561                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2562                 if(cbpy<0){
2563                     fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2564                     return DECODING_AC_LOST;
2565                 }
2566
2567                 s->cbp_table[xy]|= cbpy<<2;
2568                 s->pred_dir_table[xy]|= ac_pred<<7;
2569             }else{ /* P || S_TYPE */
2570                 if(s->mb_type[xy]&MB_TYPE_INTRA){
2571                     int dir=0,i;
2572                     int ac_pred = get_bits1(&s->gb);
2573                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2574
2575                     if(cbpy<0){
2576                         fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2577                         return DECODING_ACDC_LOST;
2578                     }
2579
2580                     if(s->cbp_table[xy] & 8) {
2581                         change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2582                     }
2583                     s->qscale_table[xy]= s->qscale;
2584
2585                     for(i=0; i<6; i++){
2586                         int dc_pred_dir;
2587                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2588                         if(dc < 0){
2589                             fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2590                             return DECODING_ACDC_LOST;
2591                         }
2592                         dir<<=1;
2593                         if(dc_pred_dir) dir|=1;
2594                     }
2595                     s->cbp_table[xy]&= 3; //remove dquant
2596                     s->cbp_table[xy]|= cbpy<<2;
2597                     s->pred_dir_table[xy]= dir | (ac_pred<<7);
2598                 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2599                     s->qscale_table[xy]= s->qscale;
2600                     s->cbp_table[xy]= 0;
2601                 }else{
2602                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2603
2604                     if(cbpy<0){
2605                         fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2606                         return DECODING_ACDC_LOST;
2607                     }
2608
2609                     if(s->cbp_table[xy] & 8) {
2610                         change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2611                     }
2612                     s->qscale_table[xy]= s->qscale;
2613
2614                     s->cbp_table[xy]&= 3; //remove dquant
2615                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
2616                 }
2617             }
2618         }
2619         s->mb_x= 0;
2620     }
2621
2622
2623     return 0;
2624 }
2625
2626 static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
2627                    DCTELEM block[6][64])
2628 {
2629     int cbp, mb_type;
2630     const int xy= s->mb_x + s->mb_y*s->mb_width;
2631
2632     if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
2633         int i;
2634         int block_index_backup[6];
2635         int qscale= s->qscale;
2636
2637         for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
2638
2639         s->decoding_error= ff_mpeg4_decode_partitions(s);
2640
2641         for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
2642         s->first_slice_line=1;
2643         s->mb_x= s->resync_mb_x;
2644         s->mb_y= s->resync_mb_y;
2645         s->qscale= qscale;
2646         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2647         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2648
2649         if(s->decoding_error==DECODING_DESYNC) return -1;
2650     }
2651
2652     mb_type= s->mb_type[xy];
2653     if(s->decoding_error)
2654         cbp=0;
2655     else
2656         cbp = s->cbp_table[xy];
2657
2658     if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
2659         s->qscale= s->qscale_table[xy];
2660         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2661         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2662     }
2663
2664     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2665         int i;
2666         for(i=0; i<4; i++){
2667             s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2668             s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2669         }
2670         s->mb_intra = mb_type&MB_TYPE_INTRA;
2671
2672         if (mb_type&MB_TYPE_SKIPED) {
2673             /* skip mb */
2674             for(i=0;i<6;i++)
2675                 s->block_last_index[i] = -1;
2676             s->mv_dir = MV_DIR_FORWARD;
2677             s->mv_type = MV_TYPE_16X16;
2678             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2679                 s->mcsel=1;
2680                 s->mb_skiped = 0;
2681             }else{
2682                 s->mcsel=0;
2683                 s->mb_skiped = 1;
2684             }
2685             return 0;
2686         }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
2687             s->ac_pred = s->pred_dir_table[xy]>>7;
2688
2689             /* decode each block */
2690             for (i = 0; i < 6; i++) {
2691                 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
2692                 if(ret==DECODING_AC_LOST){
2693                     fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2694                     s->decoding_error=DECODING_AC_LOST;
2695                     cbp=0;
2696                 }else if(ret==DECODING_ACDC_LOST){
2697                     fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
2698                     s->decoding_error=DECODING_ACDC_LOST;
2699                     break;
2700                 }
2701             }
2702         }else if(!s->mb_intra){
2703 //            s->mcsel= 0; //FIXME do we need to init that
2704
2705             s->mv_dir = MV_DIR_FORWARD;
2706             if (mb_type&MB_TYPE_INTER4V) {
2707                 s->mv_type = MV_TYPE_8X8;
2708             } else {
2709                 s->mv_type = MV_TYPE_16X16;
2710             }
2711             if(s->decoding_error==0 && cbp){
2712                 /* decode each block */
2713                 for (i = 0; i < 6; i++) {
2714                     int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0);
2715                     if(ret==DECODING_AC_LOST){
2716                         fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2717                         s->decoding_error=DECODING_AC_LOST;
2718                         break;
2719                     }
2720                 }
2721             }
2722         }
2723     } else { /* I-Frame */
2724         int i;
2725         s->mb_intra = 1;
2726         s->ac_pred = s->pred_dir_table[xy]>>7;
2727
2728         /* decode each block */
2729         for (i = 0; i < 6; i++) {
2730             int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
2731             if(ret==DECODING_AC_LOST){
2732                 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2733                 s->decoding_error=DECODING_AC_LOST;
2734                 cbp=0;
2735             }else if(ret==DECODING_ACDC_LOST){
2736                 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
2737                 return -1;
2738             }
2739         }
2740     }
2741
2742     return 0;
2743 }
2744 #if 0
2745 static inline void decode_interlaced_info(MpegEncContext *s, int cbp, int mb_type){
2746     s->mv_type= 0;
2747     if(!s->progressive_sequence){
2748         if(cbp || s->mb_intra)
2749             s->interlaced_dct= get_bits1(&s->gb);
2750
2751         if(!s->mb_intra){
2752             if(   s->pict_type==P_TYPE //FIXME check that 4MV is forbidden
2753                || (s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && !s->mcsel)
2754                || (s->pict_type==B_TYPE && mb_type!=0) ){
2755
2756                 if(get_bits1(&s->gb)){
2757                     s->mv_type= MV_TYPE_FIELD;
2758
2759                     if(   s->pict_type==P_TYPE
2760                        || (s->pict_type==B_TYPE && mb_type!=2)){
2761                         s->field_select[0][0]= get_bits1(&s->gb);
2762                         s->field_select[0][1]= get_bits1(&s->gb);
2763                     }
2764                     if(s->pict_type==B_TYPE && mb_type!=3){
2765                         s->field_select[1][0]= get_bits1(&s->gb);
2766                         s->field_select[1][1]= get_bits1(&s->gb);
2767                     }
2768                 }else
2769                     s->mv_type= 0;
2770             }
2771         }
2772     }
2773 }
2774 #endif
2775
2776 int h263_decode_mb(MpegEncContext *s,
2777                    DCTELEM block[6][64])
2778 {
2779     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2780     INT16 *mot_val;
2781     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2782
2783     if(s->mb_x==0) PRINT_MB_TYPE("\n");
2784
2785     if(s->resync_marker){
2786         if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
2787             s->first_slice_line=0;
2788         }
2789     }
2790
2791     if(s->data_partitioning && s->pict_type!=B_TYPE)
2792         return mpeg4_decode_partitioned_mb(s, block);
2793
2794     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2795         if (get_bits1(&s->gb)) {
2796             /* skip mb */
2797             s->mb_intra = 0;
2798             for(i=0;i<6;i++)
2799                 s->block_last_index[i] = -1;
2800             s->mv_dir = MV_DIR_FORWARD;
2801             s->mv_type = MV_TYPE_16X16;
2802             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2803                 const int a= s->sprite_warping_accuracy;
2804 //                int l = (1 << (s->f_code - 1)) * 32;
2805                 PRINT_MB_TYPE("G");
2806                 s->mcsel=1;
2807                 if(s->divx_version==500 && s->divx_build==413){
2808                     s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2809                     s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2810                 }else{
2811                     s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2812                     s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2813                 }
2814 /*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
2815                 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
2816                 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
2817                 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
2818
2819                 s->mb_skiped = 0;
2820             }else{
2821                 PRINT_MB_TYPE("S");
2822                 s->mcsel=0;
2823                 s->mv[0][0][0] = 0;
2824                 s->mv[0][0][1] = 0;
2825                 s->mb_skiped = 1;
2826             }
2827             return 0;
2828         }
2829         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2830         //fprintf(stderr, "\tCBPC: %d", cbpc);
2831         if (cbpc < 0)
2832             return -1;
2833         if (cbpc > 20)
2834             cbpc+=3;
2835         else if (cbpc == 20)
2836             fprintf(stderr, "Stuffing !");
2837
2838         dquant = cbpc & 8;
2839         s->mb_intra = ((cbpc & 4) != 0);
2840         if (s->mb_intra) goto intra;
2841
2842         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2843             s->mcsel= get_bits1(&s->gb);
2844         else s->mcsel= 0;
2845         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2846         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2847         if (dquant) {
2848             change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2849         }
2850         if((!s->progressive_sequence) && (cbp || s->workaround_bugs==2))
2851             s->interlaced_dct= get_bits1(&s->gb);
2852
2853         s->mv_dir = MV_DIR_FORWARD;
2854         if ((cbpc & 16) == 0) {
2855             if(s->mcsel){
2856                 const int a= s->sprite_warping_accuracy;
2857                 PRINT_MB_TYPE("G");
2858                 /* 16x16 global motion prediction */
2859                 s->mv_type = MV_TYPE_16X16;
2860 //        int l = (1 << (s->f_code - 1)) * 32;
2861                 if(s->divx_version==500 && s->divx_build==413){
2862                     mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2863                     my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2864                 }else{
2865                     mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2866                     my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2867                 }
2868 //       int l = (1 << (s->f_code - 1)) * 32;
2869                 s->mv[0][0][0] = mx;
2870                 s->mv[0][0][1] = my;
2871             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2872                 PRINT_MB_TYPE("f");
2873                 /* 16x8 field motion prediction */
2874                 s->mv_type= MV_TYPE_FIELD;
2875
2876                 s->field_select[0][0]= get_bits1(&s->gb);
2877                 s->field_select[0][1]= get_bits1(&s->gb);
2878
2879                 h263_pred_motion(s, 0, &pred_x, &pred_y);
2880
2881                 for(i=0; i<2; i++){
2882                     mx = h263_decode_motion(s, pred_x, s->f_code);
2883                     if (mx >= 0xffff)
2884                         return -1;
2885
2886                     my = h263_decode_motion(s, pred_y/2, s->f_code);
2887                     if (my >= 0xffff)
2888                         return -1;
2889
2890                     s->mv[0][i][0] = mx;
2891                     s->mv[0][i][1] = my;
2892                 }
2893             }else{
2894                 PRINT_MB_TYPE("P");
2895                 /* 16x16 motion prediction */
2896                 s->mv_type = MV_TYPE_16X16;
2897                 h263_pred_motion(s, 0, &pred_x, &pred_y);
2898                 if (s->umvplus_dec)
2899                    mx = h263p_decode_umotion(s, pred_x);
2900                 else
2901                    mx = h263_decode_motion(s, pred_x, s->f_code);
2902
2903                 if (mx >= 0xffff)
2904                     return -1;
2905
2906                 if (s->umvplus_dec)
2907                    my = h263p_decode_umotion(s, pred_y);
2908                 else
2909                    my = h263_decode_motion(s, pred_y, s->f_code);
2910
2911                 if (my >= 0xffff)
2912                     return -1;
2913                 s->mv[0][0][0] = mx;
2914                 s->mv[0][0][1] = my;
2915
2916                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2917                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2918             }
2919         } else {
2920             PRINT_MB_TYPE("4");
2921             s->mv_type = MV_TYPE_8X8;
2922             for(i=0;i<4;i++) {
2923                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2924                 if (s->umvplus_dec)
2925                   mx = h263p_decode_umotion(s, pred_x);
2926                 else
2927                   mx = h263_decode_motion(s, pred_x, s->f_code);
2928                 if (mx >= 0xffff)
2929                     return -1;
2930
2931                 if (s->umvplus_dec)
2932                   my = h263p_decode_umotion(s, pred_y);
2933                 else
2934                   my = h263_decode_motion(s, pred_y, s->f_code);
2935                 if (my >= 0xffff)
2936                     return -1;
2937                 s->mv[0][i][0] = mx;
2938                 s->mv[0][i][1] = my;
2939                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2940                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2941                 mot_val[0] = mx;
2942                 mot_val[1] = my;
2943             }
2944         }
2945     } else if(s->pict_type==B_TYPE) {
2946         int modb1; // first bit of modb
2947         int modb2; // second bit of modb
2948         int mb_type;
2949         uint16_t time_pp;
2950         uint16_t time_pb;
2951         int xy;
2952
2953         s->mb_intra = 0; //B-frames never contain intra blocks
2954         s->mcsel=0;      //     ...               true gmc blocks
2955
2956         if(s->mb_x==0){
2957             for(i=0; i<2; i++){
2958                 s->last_mv[i][0][0]=
2959                 s->last_mv[i][0][1]=
2960                 s->last_mv[i][1][0]=
2961                 s->last_mv[i][1][1]= 0;
2962             }
2963         }
2964
2965         /* if we skipped it in the future P Frame than skip it now too */
2966         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
2967
2968         if(s->mb_skiped){
2969                 /* skip mb */
2970             for(i=0;i<6;i++)
2971                 s->block_last_index[i] = -1;
2972
2973             s->mv_dir = MV_DIR_FORWARD;
2974             s->mv_type = MV_TYPE_16X16;
2975             s->mv[0][0][0] = 0;
2976             s->mv[0][0][1] = 0;
2977             s->mv[1][0][0] = 0;
2978             s->mv[1][0][1] = 0;
2979             PRINT_MB_TYPE("s");
2980             return 0;
2981         }
2982
2983         modb1= get_bits1(&s->gb);
2984         if(modb1){
2985             mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
2986             cbp=0;
2987         }else{
2988             int field_mv;
2989
2990             modb2= get_bits1(&s->gb);
2991             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
2992             if(modb2) cbp= 0;
2993             else      cbp= get_bits(&s->gb, 6);
2994
2995             if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
2996                 if(get_bits1(&s->gb)){
2997                     change_qscale(s, get_bits1(&s->gb)*4 - 2);
2998                 }
2999             }
3000             field_mv=0;
3001
3002             if(!s->progressive_sequence){
3003                 if(cbp)
3004                     s->interlaced_dct= get_bits1(&s->gb);
3005
3006                 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
3007                     field_mv=1;
3008
3009                     if(mb_type!=MB_TYPE_B_BACKW){
3010                         s->field_select[0][0]= get_bits1(&s->gb);
3011                         s->field_select[0][1]= get_bits1(&s->gb);
3012                     }
3013                     if(mb_type!=MB_TYPE_B_FORW){
3014                         s->field_select[1][0]= get_bits1(&s->gb);
3015                         s->field_select[1][1]= get_bits1(&s->gb);
3016                     }
3017                 }
3018             }
3019
3020             s->mv_dir = 0;
3021             if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3022                 s->mv_type= MV_TYPE_16X16;
3023                 if(mb_type!=MB_TYPE_B_BACKW){
3024                     s->mv_dir = MV_DIR_FORWARD;
3025
3026                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3027                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3028                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3029                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3030                 }
3031
3032                 if(mb_type!=MB_TYPE_B_FORW){
3033                     s->mv_dir |= MV_DIR_BACKWARD;
3034
3035                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3036                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3037                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3038                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3039                 }
3040                 if(mb_type!=MB_TYPE_B_DIRECT)
3041                     PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3042             }else if(mb_type!=MB_TYPE_B_DIRECT){
3043                 s->mv_type= MV_TYPE_FIELD;
3044
3045                 if(mb_type!=MB_TYPE_B_BACKW){
3046                     s->mv_dir = MV_DIR_FORWARD;
3047
3048                     for(i=0; i<2; i++){
3049                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3050                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3051                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3052                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3053                     }
3054                 }
3055
3056                 if(mb_type!=MB_TYPE_B_FORW){
3057                     s->mv_dir |= MV_DIR_BACKWARD;
3058
3059                     for(i=0; i<2; i++){
3060                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3061                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3062                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3063                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3064                     }
3065                 }
3066                 if(mb_type!=MB_TYPE_B_DIRECT)
3067                     PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
3068             }
3069         }
3070
3071         if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
3072             int mb_index= s->mb_x + s->mb_y*s->mb_width;
3073             int i;
3074
3075             if(mb_type==4)
3076                 mx=my=0;
3077             else{
3078                 mx = h263_decode_motion(s, 0, 1);
3079                 my = h263_decode_motion(s, 0, 1);
3080             }
3081
3082             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3083             xy= s->block_index[0];
3084             time_pp= s->pp_time;
3085             time_pb= s->pb_time;
3086
3087             //FIXME avoid divides
3088             switch(s->co_located_type_table[mb_index]){
3089             case 0:
3090                 s->mv_type= MV_TYPE_16X16;
3091                 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3092                 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3093                 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
3094                                     : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3095                 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
3096                                     : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3097                 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
3098                 break;
3099             case CO_LOCATED_TYPE_4MV:
3100                 s->mv_type = MV_TYPE_8X8;
3101                 for(i=0; i<4; i++){
3102                     xy= s->block_index[i];
3103                     s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
3104                     s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
3105                     s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
3106                                         : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
3107                     s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
3108                                         : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
3109                 }
3110                 PRINT_MB_TYPE("4");
3111                 break;
3112             case CO_LOCATED_TYPE_FIELDMV:
3113                 s->mv_type = MV_TYPE_FIELD;
3114                 for(i=0; i<2; i++){
3115                     if(s->top_field_first){
3116                         time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
3117                         time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
3118                     }else{
3119                         time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
3120                         time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
3121                     }
3122                     s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
3123                     s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
3124                     s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
3125                                         : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
3126                     s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
3127                                         : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
3128                 }
3129                 PRINT_MB_TYPE("=");
3130                 break;
3131             }
3132         }
3133
3134         if(mb_type<0 || mb_type>4){
3135             printf("illegal MB_type\n");
3136             return -1;
3137         }
3138     } else { /* I-Frame */
3139         cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3140         if (cbpc < 0)
3141             return -1;
3142         dquant = cbpc & 4;
3143         s->mb_intra = 1;
3144 intra:
3145         s->ac_pred = 0;
3146         if (s->h263_pred || s->h263_aic) {
3147             s->ac_pred = get_bits1(&s->gb);
3148             if (s->ac_pred && s->h263_aic)
3149                 s->h263_aic_dir = get_bits1(&s->gb);
3150         }
3151         PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3152
3153         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3154         if(cbpy<0) return -1;
3155         cbp = (cbpc & 3) | (cbpy << 2);
3156         if (dquant) {
3157             change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3158         }
3159         if(!s->progressive_sequence)
3160             s->interlaced_dct= get_bits1(&s->gb);
3161
3162         /* decode each block */
3163         if (s->h263_pred) {
3164             for (i = 0; i < 6; i++) {
3165                 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1) < 0)
3166                     return -1;
3167             }
3168         } else {
3169             for (i = 0; i < 6; i++) {
3170                 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
3171                     return -1;
3172             }
3173         }
3174         return 0;
3175     }
3176
3177     /* decode each block */
3178     if (s->h263_pred) {
3179         for (i = 0; i < 6; i++) {
3180             if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0) < 0)
3181                 return -1;
3182         }
3183     } else {
3184         for (i = 0; i < 6; i++) {
3185             if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
3186                 return -1;
3187         }
3188     }
3189     return 0;
3190 }
3191
3192 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3193 {
3194     int code, val, sign, shift, l;
3195
3196     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3197     if (code < 0)
3198         return 0xffff;
3199
3200     if (code == 0)
3201         return pred;
3202     sign = get_bits1(&s->gb);
3203     shift = f_code - 1;
3204     val = (code - 1) << shift;
3205     if (shift > 0)
3206         val |= get_bits(&s->gb, shift);
3207     val++;
3208     if (sign)
3209         val = -val;
3210     val += pred;
3211
3212     /* modulo decoding */
3213     if (!s->h263_long_vectors) {
3214         l = (1 << (f_code - 1)) * 32;
3215         if (val < -l) {
3216             val += l<<1;
3217         } else if (val >= l) {
3218             val -= l<<1;
3219         }
3220     } else {
3221         /* horrible h263 long vector mode */
3222         if (pred < -31 && val < -63)
3223             val += 64;
3224         if (pred > 32 && val > 63)
3225             val -= 64;
3226
3227     }
3228     return val;
3229 }
3230
3231 /* Decodes RVLC of H.263+ UMV */
3232 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3233 {
3234    int code = 0, sign;
3235
3236    if (get_bits1(&s->gb)) /* Motion difference = 0 */
3237       return pred;
3238
3239    code = 2 + get_bits1(&s->gb);
3240
3241    while (get_bits1(&s->gb))
3242    {
3243       code <<= 1;
3244       code += get_bits1(&s->gb);
3245    }
3246    sign = code & 1;
3247    code >>= 1;
3248
3249    code = (sign) ? (pred - code) : (pred + code);
3250 #ifdef DEBUG
3251    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3252 #endif
3253    return code;
3254
3255 }
3256
3257 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3258                              int n, int coded)
3259 {
3260     int code, level, i, j, last, run;
3261     RLTable *rl = &rl_inter;
3262     const UINT8 *scan_table;
3263
3264     scan_table = zigzag_direct;
3265     if (s->h263_aic && s->mb_intra) {
3266         rl = &rl_intra_aic;
3267         i = 0;
3268         if (s->ac_pred) {
3269             if (s->h263_aic_dir)
3270                 scan_table = ff_alternate_vertical_scan; /* left */
3271             else
3272                 scan_table = ff_alternate_horizontal_scan; /* top */
3273         }
3274     } else if (s->mb_intra) {
3275         /* DC coef */
3276         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3277             int component, diff;
3278             component = (n <= 3 ? 0 : n - 4 + 1);
3279             level = s->last_dc[component];
3280             if (s->rv10_first_dc_coded[component]) {
3281                 diff = rv_decode_dc(s, n);
3282                 if (diff == 0xffff)
3283                     return -1;
3284                 level += diff;
3285                 level = level & 0xff; /* handle wrap round */
3286                 s->last_dc[component] = level;
3287             } else {
3288                 s->rv10_first_dc_coded[component] = 1;
3289             }
3290         } else {
3291             level = get_bits(&s->gb, 8);
3292             if (level == 255)
3293                 level = 128;
3294         }
3295         block[0] = level;
3296         i = 1;
3297     } else {
3298         i = 0;
3299     }
3300     if (!coded) {
3301         if (s->mb_intra && s->h263_aic)
3302             goto not_coded;
3303         s->block_last_index[n] = i - 1;
3304         return 0;
3305     }
3306
3307     for(;;) {
3308         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3309         if (code < 0)
3310             return -1;
3311         if (code == rl->n) {
3312             /* escape */
3313             last = get_bits1(&s->gb);
3314             run = get_bits(&s->gb, 6);
3315             level = (INT8)get_bits(&s->gb, 8);
3316             if (s->h263_rv10 && level == -128) {
3317                 /* XXX: should patch encoder too */
3318                 level = get_bits(&s->gb, 12);
3319                 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3320             }
3321         } else {
3322             run = rl->table_run[code];
3323             level = rl->table_level[code];
3324             last = code >= rl->last;
3325             if (get_bits1(&s->gb))
3326                 level = -level;
3327         }
3328         i += run;
3329         if (i >= 64)
3330             return -1;
3331         j = scan_table[i];
3332         block[j] = level;
3333         if (last)
3334             break;
3335         i++;
3336     }
3337 not_coded:
3338     if (s->mb_intra && s->h263_aic) {
3339         h263_pred_acdc(s, block, n);
3340         i = 63;
3341     }
3342     s->block_last_index[n] = i;
3343     return 0;
3344 }
3345
3346 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3347 {
3348     int level, pred, code;
3349     UINT16 *dc_val;
3350
3351     if (n < 4)
3352         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3353     else
3354         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3355     if (code < 0 || code > 9 /* && s->nbit<9 */){
3356         fprintf(stderr, "illegal dc vlc\n");
3357         return -1;
3358     }
3359     if (code == 0) {
3360         level = 0;
3361     } else {
3362         level = get_bits(&s->gb, code);
3363         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3364             level = - (level ^ ((1 << code) - 1));
3365         if (code > 8){
3366             if(get_bits1(&s->gb)==0){ /* marker */
3367                 fprintf(stderr, "dc marker bit missing\n");
3368                 return -1;
3369             }
3370         }
3371     }
3372
3373     pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3374     level += pred;
3375     if (level < 0)
3376         level = 0;
3377     if (n < 4) {
3378         *dc_val = level * s->y_dc_scale;
3379     } else {
3380         *dc_val = level * s->c_dc_scale;
3381     }
3382     return level;
3383 }
3384
3385 /**
3386  * decode a block
3387  * returns 0 if everything went ok
3388  * returns DECODING_AC_LOST   if an error was detected during AC decoding
3389  * returns DECODING_ACDC_LOST if an error was detected during DC decoding
3390  */
3391 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3392                               int n, int coded, int intra)
3393 {
3394     int level, i, last, run;
3395     int dc_pred_dir;
3396     RLTable * rl;
3397     RL_VLC_ELEM * rl_vlc;
3398     const UINT8 * scan_table;
3399     int qmul, qadd;
3400
3401     if(intra) {
3402         /* DC coef */
3403         if(s->data_partitioning && s->pict_type!=B_TYPE){
3404             level = s->dc_val[0][ s->block_index[n] ];
3405             if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3406             else    level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3407             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3408         }else{
3409             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3410             if (level < 0)
3411                 return DECODING_ACDC_LOST;
3412         }
3413         block[0] = level;
3414         i = 0;
3415         if (!coded)
3416             goto not_coded;
3417         rl = &rl_intra;
3418         rl_vlc = rl_intra.rl_vlc[0];
3419         if(s->alternate_scan)
3420             scan_table = ff_alternate_vertical_scan; /* left */
3421         else if (s->ac_pred) {
3422             if (dc_pred_dir == 0)
3423                 scan_table = ff_alternate_vertical_scan; /* left */
3424             else
3425                 scan_table = ff_alternate_horizontal_scan; /* top */
3426         } else {
3427             scan_table = zigzag_direct;
3428         }
3429         qmul=1;
3430         qadd=0;
3431     } else {
3432         i = -1;
3433         if (!coded) {
3434             s->block_last_index[n] = i;
3435             return 0;
3436         }
3437         rl = &rl_inter;
3438
3439         if(s->alternate_scan)
3440             scan_table = ff_alternate_vertical_scan; /* left */
3441         else
3442             scan_table = zigzag_direct;
3443
3444         if(s->mpeg_quant){
3445             qmul=1;
3446             qadd=0;
3447             rl_vlc = rl_inter.rl_vlc[0];
3448         }else{
3449             qmul = s->qscale << 1;
3450             qadd = (s->qscale - 1) | 1;
3451             rl_vlc = rl_inter.rl_vlc[s->qscale];
3452         }
3453     }
3454   {
3455     OPEN_READER(re, &s->gb);
3456     for(;;) {
3457         UPDATE_CACHE(re, &s->gb);
3458         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3459         if (level==0) {
3460             int cache;
3461             cache= GET_CACHE(re, &s->gb);
3462             /* escape */
3463             if (cache&0x80000000) {
3464                 if (cache&0x40000000) {
3465                     /* third escape */
3466                     SKIP_CACHE(re, &s->gb, 2);
3467                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3468                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3469                     SKIP_COUNTER(re, &s->gb, 2+1+6);
3470                     UPDATE_CACHE(re, &s->gb);
3471
3472                     if(SHOW_UBITS(re, &s->gb, 1)==0){
3473                         fprintf(stderr, "1. marker bit missing in 3. esc\n");
3474                         return DECODING_AC_LOST;
3475                     }; SKIP_CACHE(re, &s->gb, 1);
3476
3477                     level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3478
3479                     if(SHOW_UBITS(re, &s->gb, 1)==0){
3480                         fprintf(stderr, "2. marker bit missing in 3. esc\n");
3481                         return DECODING_AC_LOST;
3482                     }; LAST_SKIP_CACHE(re, &s->gb, 1);
3483
3484                     SKIP_COUNTER(re, &s->gb, 1+12+1);
3485
3486                     if(level*s->qscale>1024 || level*s->qscale<-1024){
3487                         fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3488                         return DECODING_AC_LOST;
3489                     }
3490 #if 1
3491                     {
3492                         const int abs_level= ABS(level);
3493                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
3494                             const int run1= run - rl->max_run[last][abs_level] - 1;
3495                             if(abs_level <= rl->max_level[last][run]){
3496                                 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3497                                 return DECODING_AC_LOST;
3498                             }
3499                             if(abs_level <= rl->max_level[last][run]*2){
3500                                 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3501                                 return DECODING_AC_LOST;
3502                             }
3503                             if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3504                                 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3505                                 return DECODING_AC_LOST;
3506                             }
3507                         }
3508                     }
3509 #endif
3510                     if (level>0) level= level * qmul + qadd;
3511                     else         level= level * qmul - qadd;
3512
3513                     i+= run + 1;
3514                     if(last) i+=192;
3515                 } else {
3516                     /* second escape */
3517 #if MIN_CACHE_BITS < 20
3518                     LAST_SKIP_BITS(re, &s->gb, 2);
3519                     UPDATE_CACHE(re, &s->gb);
3520 #else
3521                     SKIP_BITS(re, &s->gb, 2);
3522 #endif
3523                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3524                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3525                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3526                     LAST_SKIP_BITS(re, &s->gb, 1);
3527                 }
3528             } else {
3529                 /* first escape */
3530 #if MIN_CACHE_BITS < 19
3531                 LAST_SKIP_BITS(re, &s->gb, 1);
3532                 UPDATE_CACHE(re, &s->gb);
3533 #else
3534                 SKIP_BITS(re, &s->gb, 1);
3535 #endif
3536                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3537                 i+= run;
3538                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3539                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3540                 LAST_SKIP_BITS(re, &s->gb, 1);
3541             }
3542         } else {
3543             i+= run;
3544             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3545             LAST_SKIP_BITS(re, &s->gb, 1);
3546         }
3547         if (i > 62){
3548             i-= 192;
3549             if(i&(~63)){
3550                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3551                 return DECODING_AC_LOST;
3552             }
3553
3554             block[scan_table[i]] = level;
3555             break;
3556         }
3557
3558         block[scan_table[i]] = level;
3559     }
3560     CLOSE_READER(re, &s->gb);
3561   }
3562  not_coded:
3563     if (s->mb_intra) {
3564         mpeg4_pred_ac(s, block, n, dc_pred_dir);
3565         if (s->ac_pred) {
3566             i = 63; /* XXX: not optimal */
3567         }
3568     }
3569     s->block_last_index[n] = i;
3570     return 0;
3571 }
3572
3573 /* most is hardcoded. should extend to handle all h263 streams */
3574 int h263_decode_picture_header(MpegEncContext *s)
3575 {
3576     int format, width, height;
3577
3578     /* picture start code */
3579     if (get_bits(&s->gb, 22) != 0x20) {
3580         fprintf(stderr, "Bad picture start code\n");
3581         return -1;
3582     }
3583     /* temporal reference */
3584     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3585
3586     /* PTYPE starts here */
3587     if (get_bits1(&s->gb) != 1) {
3588         /* marker */
3589         fprintf(stderr, "Bad marker\n");
3590         return -1;
3591     }
3592     if (get_bits1(&s->gb) != 0) {
3593         fprintf(stderr, "Bad H263 id\n");
3594         return -1;      /* h263 id */
3595     }
3596     skip_bits1(&s->gb); /* split screen off */
3597     skip_bits1(&s->gb); /* camera  off */
3598     skip_bits1(&s->gb); /* freeze picture release off */
3599
3600     /* Reset GOB number */
3601     s->gob_number = 0;
3602
3603     format = get_bits(&s->gb, 3);
3604     /*
3605         0    forbidden
3606         1    sub-QCIF
3607         10   QCIF
3608         7       extended PTYPE (PLUSPTYPE)
3609     */
3610
3611     if (format != 7 && format != 6) {
3612         s->h263_plus = 0;
3613         /* H.263v1 */
3614         width = h263_format[format][0];
3615         height = h263_format[format][1];
3616         if (!width)
3617             return -1;
3618
3619         s->width = width;
3620         s->height = height;
3621         s->pict_type = I_TYPE + get_bits1(&s->gb);
3622
3623         s->unrestricted_mv = get_bits1(&s->gb);
3624         s->h263_long_vectors = s->unrestricted_mv;
3625
3626         if (get_bits1(&s->gb) != 0) {
3627             fprintf(stderr, "H263 SAC not supported\n");
3628             return -1;  /* SAC: off */
3629         }
3630         if (get_bits1(&s->gb) != 0) {
3631             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3632         }
3633
3634         if (get_bits1(&s->gb) != 0) {
3635             fprintf(stderr, "H263 PB frame not supported\n");
3636             return -1;  /* not PB frame */
3637         }
3638         s->qscale = get_bits(&s->gb, 5);
3639         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
3640     } else {
3641         int ufep;
3642
3643         /* H.263v2 */
3644         s->h263_plus = 1;
3645         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3646
3647         /* ufep other than 0 and 1 are reserved */
3648         if (ufep == 1) {
3649             /* OPPTYPE */
3650             format = get_bits(&s->gb, 3);
3651             dprintf("ufep=1, format: %d\n", format);
3652             skip_bits(&s->gb,1); /* Custom PCF */
3653             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3654             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3655             if (get_bits1(&s->gb) != 0) {
3656                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3657             }
3658             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3659                 s->h263_aic = 1;
3660             }
3661
3662             skip_bits(&s->gb, 7);
3663             /* these are the 7 bits: (in order of appearence  */
3664             /* Deblocking Filter */
3665             /* Slice Structured */
3666             /* Reference Picture Selection */
3667             /* Independent Segment Decoding */
3668             /* Alternative Inter VLC */
3669             /* Modified Quantization */
3670             /* Prevent start code emulation */
3671
3672             skip_bits(&s->gb, 3); /* Reserved */
3673         } else if (ufep != 0) {
3674             fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3675             return -1;
3676         }
3677
3678         /* MPPTYPE */
3679         s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3680         dprintf("pict_type: %d\n", s->pict_type);
3681         if (s->pict_type != I_TYPE &&
3682             s->pict_type != P_TYPE)
3683             return -1;
3684         skip_bits(&s->gb, 2);
3685         s->no_rounding = get_bits1(&s->gb);
3686         dprintf("RTYPE: %d\n", s->no_rounding);
3687         skip_bits(&s->gb, 4);
3688
3689         /* Get the picture dimensions */
3690         if (ufep) {
3691             if (format == 6) {
3692                 /* Custom Picture Format (CPFMT) */
3693                 s->aspect_ratio_info = get_bits(&s->gb, 4);
3694                 dprintf("aspect: %d\n", s->aspect_ratio_info);
3695                 /* aspect ratios:
3696                 0 - forbidden
3697                 1 - 1:1
3698                 2 - 12:11 (CIF 4:3)
3699                 3 - 10:11 (525-type 4:3)
3700                 4 - 16:11 (CIF 16:9)
3701                 5 - 40:33 (525-type 16:9)
3702                 6-14 - reserved
3703                 */
3704                 width = (get_bits(&s->gb, 9) + 1) * 4;
3705                 skip_bits1(&s->gb);
3706                 height = get_bits(&s->gb, 9) * 4;
3707                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3708                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
3709                     /* aspected dimensions */
3710                     s->aspected_width = get_bits(&s->gb, 8);
3711                     s->aspected_height = get_bits(&s->gb, 8);
3712                 }
3713             } else {
3714                 width = h263_format[format][0];
3715                 height = h263_format[format][1];
3716             }
3717             if ((width == 0) || (height == 0))
3718                 return -1;
3719             s->width = width;
3720             s->height = height;
3721             if (s->umvplus_dec) {
3722                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3723             }
3724         }
3725
3726         s->qscale = get_bits(&s->gb, 5);
3727     }
3728     /* PEI */
3729     while (get_bits1(&s->gb) != 0) {
3730         skip_bits(&s->gb, 8);
3731     }
3732     s->f_code = 1;
3733
3734     if(s->h263_aic){
3735          s->y_dc_scale_table=
3736          s->c_dc_scale_table= h263_aic_dc_scale_table;
3737     }else{
3738         s->y_dc_scale_table=
3739         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3740     }
3741
3742     return 0;
3743 }
3744
3745 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3746 {
3747     int i;
3748     int a= 2<<s->sprite_warping_accuracy;
3749     int rho= 3-s->sprite_warping_accuracy;
3750     int r=16/a;
3751     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3752     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3753     int sprite_ref[4][2];
3754     int virtual_ref[2][2];
3755     int w2, h2;
3756     int alpha=0, beta=0;
3757     int w= s->width;
3758     int h= s->height;
3759 //printf("SP %d\n", s->sprite_warping_accuracy);
3760     for(i=0; i<s->num_sprite_warping_points; i++){
3761         int length;
3762         int x=0, y=0;
3763
3764         length= get_vlc(&s->gb, &sprite_trajectory);
3765         if(length){
3766             x= get_bits(&s->gb, length);
3767 //printf("lx %d %d\n", length, x);
3768             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3769                 x = - (x ^ ((1 << length) - 1));
3770         }
3771         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3772
3773         length= get_vlc(&s->gb, &sprite_trajectory);
3774         if(length){
3775             y=get_bits(&s->gb, length);
3776 //printf("ly %d %d\n", length, y);
3777             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3778                 y = - (y ^ ((1 << length) - 1));
3779         }
3780         skip_bits1(&s->gb); /* marker bit */
3781 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3782 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
3783 //x=y=0;
3784         d[i][0]= x;
3785         d[i][1]= y;
3786     }
3787
3788     while((1<<alpha)<w) alpha++;
3789     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3790     w2= 1<<alpha;
3791     h2= 1<<beta;
3792
3793 // Note, the 4th point isnt used for GMC
3794     if(s->divx_version==500 && s->divx_build==413){
3795         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3796         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3797         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3798         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3799         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3800         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3801     } else {
3802         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3803         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3804         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3805         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3806         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3807         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3808     }
3809 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3810     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3811
3812 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3813 // perhaps it should be reordered to be more readable ...
3814 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3815 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3816     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
3817         + 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);
3818     virtual_ref[0][1]= 16*vop_ref[0][1]
3819         + 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);
3820     virtual_ref[1][0]= 16*vop_ref[0][0]
3821         + 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);
3822     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
3823         + 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);
3824
3825     switch(s->num_sprite_warping_points)
3826     {
3827         case 0:
3828             s->sprite_offset[0][0]= 0;
3829             s->sprite_offset[0][1]= 0;
3830             s->sprite_offset[1][0]= 0;
3831             s->sprite_offset[1][1]= 0;
3832             s->sprite_delta[0][0][0]= a;
3833             s->sprite_delta[0][0][1]= 0;
3834             s->sprite_delta[0][1][0]= 0;
3835             s->sprite_delta[0][1][1]= a;
3836             s->sprite_delta[1][0][0]= a;
3837             s->sprite_delta[1][0][1]= 0;
3838             s->sprite_delta[1][1][0]= 0;
3839             s->sprite_delta[1][1][1]= a;
3840             s->sprite_shift[0][0]= 0;
3841             s->sprite_shift[0][1]= 0;
3842             s->sprite_shift[1][0]= 0;
3843             s->sprite_shift[1][1]= 0;
3844             break;
3845         case 1: //GMC only
3846             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3847             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3848             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3849             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3850             s->sprite_delta[0][0][0]= a;
3851             s->sprite_delta[0][0][1]= 0;
3852             s->sprite_delta[0][1][0]= 0;
3853             s->sprite_delta[0][1][1]= a;
3854             s->sprite_delta[1][0][0]= a;
3855             s->sprite_delta[1][0][1]= 0;
3856             s->sprite_delta[1][1][0]= 0;
3857             s->sprite_delta[1][1][1]= a;
3858             s->sprite_shift[0][0]= 0;
3859             s->sprite_shift[0][1]= 0;
3860             s->sprite_shift[1][0]= 0;
3861             s->sprite_shift[1][1]= 0;
3862             break;
3863         case 2:
3864         case 3: //FIXME
3865             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3866                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3867                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
3868             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3869                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3870                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
3871             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3872                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3873                                  +2*w2*r*sprite_ref[0][0] - 16*w2);
3874             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
3875                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3876                                  +2*w2*r*sprite_ref[0][1] - 16*w2);
3877             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3878             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
3879             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3880             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3881             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3882             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
3883             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
3884             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3885             s->sprite_shift[0][0]= alpha+rho;
3886             s->sprite_shift[0][1]= alpha+rho;
3887             s->sprite_shift[1][0]= alpha+rho+2;
3888             s->sprite_shift[1][1]= alpha+rho+2;
3889             break;
3890 //        case 3:
3891             break;
3892     }
3893 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
3894 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
3895 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
3896 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
3897 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
3898 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
3899 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
3900 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
3901     /* try to simplify the situation */
3902     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
3903        && s->sprite_delta[0][0][1] == 0
3904        && s->sprite_delta[0][1][0] == 0
3905        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
3906        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
3907        && s->sprite_delta[1][0][1] == 0
3908        && s->sprite_delta[1][1][0] == 0
3909        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
3910     {
3911         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
3912         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
3913         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
3914         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
3915         s->sprite_delta[0][0][0]= a;
3916         s->sprite_delta[0][0][1]= 0;
3917         s->sprite_delta[0][1][0]= 0;
3918         s->sprite_delta[0][1][1]= a;
3919         s->sprite_delta[1][0][0]= a;
3920         s->sprite_delta[1][0][1]= 0;
3921         s->sprite_delta[1][1][0]= 0;
3922         s->sprite_delta[1][1][1]= a;
3923         s->sprite_shift[0][0]= 0;
3924         s->sprite_shift[0][1]= 0;
3925         s->sprite_shift[1][0]= 0;
3926         s->sprite_shift[1][1]= 0;
3927         s->real_sprite_warping_points=1;
3928     }
3929     else
3930         s->real_sprite_warping_points= s->num_sprite_warping_points;
3931
3932 //printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
3933 }
3934
3935 /* decode mpeg4 VOP header */
3936 int mpeg4_decode_picture_header(MpegEncContext * s)
3937 {
3938     int time_incr, startcode, state, v;
3939     int time_increment;
3940
3941  redo:
3942     /* search next start code */
3943     align_get_bits(&s->gb);
3944     state = 0xff;
3945     for(;;) {
3946         v = get_bits(&s->gb, 8);
3947         if (state == 0x000001) {
3948             state = ((state << 8) | v) & 0xffffff;
3949             startcode = state;
3950             break;
3951         }
3952         state = ((state << 8) | v) & 0xffffff;
3953         if( get_bits_count(&s->gb) > s->gb.size*8-32){
3954             if(s->gb.size>50){
3955                 printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
3956                 return -1;
3957             }else{
3958                 printf("frame skip\n");
3959                 return FRAME_SKIPED;
3960             }
3961         }
3962     }
3963 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
3964     if (startcode == 0x120) { // Video Object Layer
3965         int width, height, vo_ver_id;
3966
3967         /* vol header */
3968         skip_bits(&s->gb, 1); /* random access */
3969         s->vo_type= get_bits(&s->gb, 8);
3970         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
3971             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
3972             skip_bits(&s->gb, 3); /* vo_priority */
3973         } else {
3974             vo_ver_id = 1;
3975         }
3976 //printf("vo type:%d\n",s->vo_type);
3977         s->aspect_ratio_info= get_bits(&s->gb, 4);
3978         if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
3979             s->aspected_width = get_bits(&s->gb, 8); // par_width
3980             s->aspected_height = get_bits(&s->gb, 8); // par_height
3981         }
3982
3983         if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
3984             int chroma_format= get_bits(&s->gb, 2);
3985             if(chroma_format!=1){
3986                 printf("illegal chroma format\n");
3987             }
3988             s->low_delay= get_bits1(&s->gb);
3989             if(get_bits1(&s->gb)){ /* vbv parameters */
3990                 get_bits(&s->gb, 15);   /* first_half_bitrate */
3991                 skip_bits1(&s->gb);     /* marker */
3992                 get_bits(&s->gb, 15);   /* latter_half_bitrate */
3993                 skip_bits1(&s->gb);     /* marker */
3994                 get_bits(&s->gb, 15);   /* first_half_vbv_buffer_size */
3995                 skip_bits1(&s->gb);     /* marker */
3996                 get_bits(&s->gb, 3);    /* latter_half_vbv_buffer_size */
3997                 get_bits(&s->gb, 11);   /* first_half_vbv_occupancy */
3998                 skip_bits1(&s->gb);     /* marker */
3999                 get_bits(&s->gb, 15);   /* latter_half_vbv_occupancy */
4000                 skip_bits1(&s->gb);     /* marker */
4001             }
4002         }else{
4003             // set low delay flag only once so the smart? low delay detection wont be overriden
4004             if(s->picture_number==0)
4005                 s->low_delay=0;
4006         }
4007
4008         s->shape = get_bits(&s->gb, 2); /* vol shape */
4009         if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4010         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4011             printf("Gray shape not supported\n");
4012             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
4013         }
4014
4015         skip_bits1(&s->gb);   /* marker */
4016
4017         s->time_increment_resolution = get_bits(&s->gb, 16);
4018
4019         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4020         if (s->time_increment_bits < 1)
4021             s->time_increment_bits = 1;
4022         skip_bits1(&s->gb);   /* marker */
4023
4024         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
4025             skip_bits(&s->gb, s->time_increment_bits);
4026         }
4027
4028         if (s->shape != BIN_ONLY_SHAPE) {
4029             if (s->shape == RECT_SHAPE) {
4030                 skip_bits1(&s->gb);   /* marker */
4031                 width = get_bits(&s->gb, 13);
4032                 skip_bits1(&s->gb);   /* marker */
4033                 height = get_bits(&s->gb, 13);
4034                 skip_bits1(&s->gb);   /* marker */
4035                 if(width && height){ /* they should be non zero but who knows ... */
4036                     s->width = width;
4037                     s->height = height;
4038 //                    printf("width/height: %d %d\n", width, height);
4039                 }
4040             }
4041
4042             s->progressive_sequence= get_bits1(&s->gb)^1;
4043             if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4044             if (vo_ver_id == 1) {
4045                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
4046             } else {
4047                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
4048             }
4049             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4050             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4051                 if(s->vol_sprite_usage==STATIC_SPRITE){
4052                     s->sprite_width = get_bits(&s->gb, 13);
4053                     skip_bits1(&s->gb); /* marker */
4054                     s->sprite_height= get_bits(&s->gb, 13);
4055                     skip_bits1(&s->gb); /* marker */
4056                     s->sprite_left  = get_bits(&s->gb, 13);
4057                     skip_bits1(&s->gb); /* marker */
4058                     s->sprite_top   = get_bits(&s->gb, 13);
4059                     skip_bits1(&s->gb); /* marker */
4060                 }
4061                 s->num_sprite_warping_points= get_bits(&s->gb, 6);
4062                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
4063                 s->sprite_brightness_change= get_bits1(&s->gb);
4064                 if(s->vol_sprite_usage==STATIC_SPRITE)
4065                     s->low_latency_sprite= get_bits1(&s->gb);
4066             }
4067             // FIXME sadct disable bit if verid!=1 && shape not rect
4068
4069             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
4070                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
4071                 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4072                 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4073             } else {
4074                 s->quant_precision = 5;
4075             }
4076
4077             // FIXME a bunch of grayscale shape things
4078
4079             if((s->mpeg_quant=get_bits1(&s->gb))){ /* vol_quant_type */
4080                 int i, j, v;
4081
4082                 /* load default matrixes */
4083                 for(i=0; i<64; i++){
4084                     v= ff_mpeg4_default_intra_matrix[i];
4085                     s->intra_matrix[i]= v;
4086                     s->chroma_intra_matrix[i]= v;
4087
4088                     v= ff_mpeg4_default_non_intra_matrix[i];
4089                     s->inter_matrix[i]= v;
4090                     s->chroma_inter_matrix[i]= v;
4091                 }
4092
4093                 /* load custom intra matrix */
4094                 if(get_bits1(&s->gb)){
4095                     for(i=0; i<64; i++){
4096                         v= get_bits(&s->gb, 8);
4097                         if(v==0) break;
4098
4099                         j= zigzag_direct[i];
4100                         s->intra_matrix[j]= v;
4101                         s->chroma_intra_matrix[j]= v;
4102                     }
4103                 }
4104
4105                 /* load custom non intra matrix */
4106                 if(get_bits1(&s->gb)){
4107                     for(i=0; i<64; i++){
4108                         v= get_bits(&s->gb, 8);
4109                         if(v==0) break;
4110
4111                         j= zigzag_direct[i];
4112                         s->inter_matrix[j]= v;
4113                         s->chroma_inter_matrix[j]= v;
4114                     }
4115
4116                     /* replicate last value */
4117                     for(; i<64; i++){
4118                         j= zigzag_direct[i];
4119                         s->inter_matrix[j]= v;
4120                         s->chroma_inter_matrix[j]= v;
4121                     }
4122                 }
4123
4124                 // FIXME a bunch of grayscale shape things
4125             }
4126
4127             if(vo_ver_id != 1)
4128                  s->quarter_sample= get_bits1(&s->gb);
4129             else s->quarter_sample=0;
4130
4131             if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
4132
4133             s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
4134
4135             s->data_partitioning= get_bits1(&s->gb);
4136             if(s->data_partitioning){
4137                 s->rvlc= get_bits1(&s->gb);
4138                 if(s->rvlc){
4139                     printf("reversible vlc not supported\n");
4140                 }
4141             }
4142
4143             if(vo_ver_id != 1) {
4144                 s->new_pred= get_bits1(&s->gb);
4145                 if(s->new_pred){
4146                     printf("new pred not supported\n");
4147                     skip_bits(&s->gb, 2); /* requested upstream message type */
4148                     skip_bits1(&s->gb); /* newpred segment type */
4149                 }
4150                 s->reduced_res_vop= get_bits1(&s->gb);
4151                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4152             }
4153             else{
4154                 s->new_pred=0;
4155                 s->reduced_res_vop= 0;
4156             }
4157
4158             s->scalability= get_bits1(&s->gb);
4159
4160             if (s->scalability) {
4161                 GetBitContext bak= s->gb;
4162                 int dummy= s->hierachy_type= get_bits1(&s->gb);
4163                 int ref_layer_id= get_bits(&s->gb, 4);
4164                 int ref_layer_sampling_dir= get_bits1(&s->gb);
4165                 int h_sampling_factor_n= get_bits(&s->gb, 5);
4166                 int h_sampling_factor_m= get_bits(&s->gb, 5);
4167                 int v_sampling_factor_n= get_bits(&s->gb, 5);
4168                 int v_sampling_factor_m= get_bits(&s->gb, 5);
4169                 s->enhancement_type= get_bits1(&s->gb);
4170
4171                 if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
4172                    || v_sampling_factor_n==0 || v_sampling_factor_m==0 || s->workaround_bugs==1){
4173
4174 //                    fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4175                     s->scalability=0;
4176
4177                     s->gb= bak;
4178                     goto redo;
4179                 }
4180
4181                 // bin shape stuff FIXME
4182                 printf("scalability not supported\n");
4183             }
4184         }
4185 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
4186         goto redo;
4187     } else if (startcode == 0x1b2) { //userdata
4188         char buf[256];
4189         int i;
4190         int e;
4191         int ver, build;
4192
4193 //printf("user Data %X\n", show_bits(&s->gb, 32));
4194         buf[0]= show_bits(&s->gb, 8);
4195         for(i=1; i<256; i++){
4196             buf[i]= show_bits(&s->gb, 16)&0xFF;
4197             if(buf[i]==0) break;
4198             skip_bits(&s->gb, 8);
4199         }
4200         buf[255]=0;
4201         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4202         if(e!=2)
4203             e=sscanf(buf, "DivX%db%d", &ver, &build);
4204         if(e==2){
4205             s->divx_version= ver;
4206             s->divx_build= build;
4207             if(s->picture_number==0){
4208                 printf("This file was encoded with DivX%d Build%d\n", ver, build);
4209                 if(ver==500 && build==413){
4210                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
4211                 }
4212             }
4213         }
4214 //printf("User Data: %s\n", buf);
4215         goto redo;
4216     } else if (startcode != 0x1b6) { //VOP
4217         goto redo;
4218     }
4219
4220     s->pict_type = get_bits(&s->gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
4221 //if(s->pict_type!=I_TYPE) return FRAME_SKIPED;
4222     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4223         printf("low_delay flag set, but shouldnt, clearing it\n");
4224         s->low_delay=0;
4225     }
4226 // printf("pic: %d, qpel:%d part:%d resync:%d\n", s->pict_type, s->quarter_sample, s->data_partitioning, s->resync_marker);
4227
4228     if(s->time_increment_resolution==0){
4229         s->time_increment_resolution=1;
4230 //        fprintf(stderr, "time_increment_resolution is illegal\n");
4231     }
4232     time_incr=0;
4233     while (get_bits1(&s->gb) != 0)
4234         time_incr++;
4235
4236     check_marker(&s->gb, "before time_increment");
4237     time_increment= get_bits(&s->gb, s->time_increment_bits);
4238 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4239     if(s->pict_type!=B_TYPE){
4240         s->last_time_base= s->time_base;
4241         s->time_base+= time_incr;
4242         s->time= s->time_base*s->time_increment_resolution + time_increment;
4243         if(s->workaround_bugs==3 || s->avctx->fourcc == ff_get_fourcc("UMP4")){
4244             if(s->time < s->last_non_b_time){
4245 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4246                 s->time_base++;
4247                 s->time+= s->time_increment_resolution;
4248             }
4249         }
4250         s->pp_time= s->time - s->last_non_b_time;
4251         s->last_non_b_time= s->time;
4252     }else{
4253         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4254         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4255         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4256 //            printf("messed up order, seeking?, skiping current b frame\n");
4257             return FRAME_SKIPED;
4258         }
4259
4260         if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4261         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4262 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4263         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4264                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4265         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
4266                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4267     }
4268
4269     s->avctx->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4270
4271     if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
4272         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4273         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4274             if(get_bits1(&s->gb)) break;
4275         }
4276         printf("my guess is %d bits ;)\n",s->time_increment_bits);
4277     }
4278     /* vop coded */
4279     if (get_bits1(&s->gb) != 1)
4280         goto redo;
4281 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4282 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4283     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4284                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4285         /* rounding type for motion estimation */
4286         s->no_rounding = get_bits1(&s->gb);
4287     } else {
4288         s->no_rounding = 0;
4289     }
4290 //FIXME reduced res stuff
4291
4292      if (s->shape != RECT_SHAPE) {
4293          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4294              int width, height, hor_spat_ref, ver_spat_ref;
4295
4296              width = get_bits(&s->gb, 13);
4297              skip_bits1(&s->gb);   /* marker */
4298              height = get_bits(&s->gb, 13);
4299              skip_bits1(&s->gb);   /* marker */
4300              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
4301              skip_bits1(&s->gb);   /* marker */
4302              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
4303          }
4304          skip_bits1(&s->gb); /* change_CR_disable */
4305
4306          if (get_bits1(&s->gb) != 0) {
4307              skip_bits(&s->gb, 8); /* constant_alpha_value */
4308          }
4309      }
4310 //FIXME complexity estimation stuff
4311
4312      if (s->shape != BIN_ONLY_SHAPE) {
4313          int t;
4314          t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
4315 //printf("threshold %d\n", t);
4316          if(!s->progressive_sequence){
4317              s->top_field_first= get_bits1(&s->gb);
4318              s->alternate_scan= get_bits1(&s->gb);
4319          }else
4320              s->alternate_scan= 0;
4321      }
4322
4323      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4324          if(s->num_sprite_warping_points){
4325              mpeg4_decode_sprite_trajectory(s);
4326          }
4327          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4328          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4329      }
4330
4331      if (s->shape != BIN_ONLY_SHAPE) {
4332          /* note: we do not use quant_precision to avoid problem if no
4333             MPEG4 vol header as it is found on some old opendivx
4334             movies */
4335          s->qscale = get_bits(&s->gb, 5);
4336          if(s->qscale==0){
4337              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4338              return -1; // makes no sense to continue, as there is nothing left from the image then
4339          }
4340
4341          if (s->pict_type != I_TYPE) {
4342              s->f_code = get_bits(&s->gb, 3);   /* fcode_for */
4343              if(s->f_code==0){
4344                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4345                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
4346              }
4347          }else
4348              s->f_code=1;
4349
4350          if (s->pict_type == B_TYPE) {
4351              s->b_code = get_bits(&s->gb, 3);
4352          }else
4353              s->b_code=1;
4354 #if 0
4355 printf("qp:%d fc:%d bc:%d type:%s size:%d pro:%d alt:%d top:%d qpel:%d part:%d resync:%d\n",
4356     s->qscale, s->f_code, s->b_code,
4357     s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4358     s->gb.size,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4359     s->quarter_sample, s->data_partitioning, s->resync_marker);
4360 #endif
4361          if(!s->scalability){
4362              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4363                  skip_bits1(&s->gb); // vop shape coding type
4364              }
4365          }else{
4366              if(s->enhancement_type){
4367                  int load_backward_shape= get_bits1(&s->gb);
4368                  if(load_backward_shape){
4369                      printf("load backward shape isnt supported\n");
4370                  }
4371              }
4372              skip_bits(&s->gb, 2); //ref_select_code
4373          }
4374      }
4375      /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4376      // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4377      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4378          printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4379          s->low_delay=1;
4380      }
4381
4382      s->picture_number++; // better than pic number==0 allways ;)
4383
4384      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
4385      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4386
4387      if(s->divx_version==0 || s->divx_version < 500){
4388          s->h_edge_pos= s->width;
4389          s->v_edge_pos= s->height;
4390      }
4391      return 0;
4392 }
4393
4394 /* don't understand why they choose a different header ! */
4395 int intel_h263_decode_picture_header(MpegEncContext *s)
4396 {
4397     int format;
4398
4399     /* picture header */
4400     if (get_bits(&s->gb, 22) != 0x20) {
4401         fprintf(stderr, "Bad picture start code\n");
4402         return -1;
4403     }
4404     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4405
4406     if (get_bits1(&s->gb) != 1) {
4407         fprintf(stderr, "Bad marker\n");
4408         return -1;      /* marker */
4409     }
4410     if (get_bits1(&s->gb) != 0) {
4411         fprintf(stderr, "Bad H263 id\n");
4412         return -1;      /* h263 id */
4413     }
4414     skip_bits1(&s->gb); /* split screen off */
4415     skip_bits1(&s->gb); /* camera  off */
4416     skip_bits1(&s->gb); /* freeze picture release off */
4417
4418     format = get_bits(&s->gb, 3);
4419     if (format != 7) {
4420         fprintf(stderr, "Intel H263 free format not supported\n");
4421         return -1;
4422     }
4423     s->h263_plus = 0;
4424
4425     s->pict_type = I_TYPE + get_bits1(&s->gb);
4426
4427     s->unrestricted_mv = get_bits1(&s->gb);
4428     s->h263_long_vectors = s->unrestricted_mv;
4429
4430     if (get_bits1(&s->gb) != 0) {
4431         fprintf(stderr, "SAC not supported\n");
4432         return -1;      /* SAC: off */
4433     }
4434     if (get_bits1(&s->gb) != 0) {
4435         fprintf(stderr, "Advanced Prediction Mode not supported\n");
4436         return -1;      /* advanced prediction mode: off */
4437     }
4438     if (get_bits1(&s->gb) != 0) {
4439         fprintf(stderr, "PB frame mode no supported\n");
4440         return -1;      /* PB frame mode */
4441     }
4442
4443     /* skip unknown header garbage */
4444     skip_bits(&s->gb, 41);
4445
4446     s->qscale = get_bits(&s->gb, 5);
4447     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4448
4449     /* PEI */
4450     while (get_bits1(&s->gb) != 0) {
4451         skip_bits(&s->gb, 8);
4452     }
4453     s->f_code = 1;
4454     return 0;
4455 }
4456