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