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

   1 /*
   2  * H263/MPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2000,2001 Gerard Lantau.
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program 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
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 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 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  35 #define MIN(a,b) ((a) < (b) ? (a) : (b))
  36
  37 #define PRINT_MB_TYPE(a) ;
  38 //#define PRINT_MB_TYPE(a) printf(a);
  39
  40 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  41                               int n);
  42 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
  43 static void h263p_encode_umotion(MpegEncContext * s, int val);
  44 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  45                                int n, int dc, UINT8 *scan_table);
  46 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
  47 static int h263p_decode_umotion(MpegEncContext * s, int pred);
  48 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  49                              int n, int coded);
  50 static 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
 269     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 270     if (!s->mb_intra) {
 271         /* compute cbp */
 272         int cbp = 0;
 273         for (i = 0; i < 6; i++) {
 274             if (s->block_last_index[i] >= 0)
 275                 cbp |= 1 << (5 - i);
 276         }
 277
 278         if(s->pict_type==B_TYPE){
 279             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
 280             int mb_type=  mb_type_table[s->mv_dir];
 281
 282             if(s->mb_x==0){
 283                 s->last_mv[0][0][0]=
 284                 s->last_mv[0][0][1]=
 285                 s->last_mv[1][0][0]=
 286                 s->last_mv[1][0][1]= 0;
 287             }
 288
 289             /* nothing to do if this MB was skiped in the next P Frame */
 290             if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
 291                 s->skip_count++;
 292                 s->mv[0][0][0]=
 293                 s->mv[0][0][1]=
 294                 s->mv[1][0][0]=
 295                 s->mv[1][0][1]= 0;
 296                 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
 297                 return;
 298             }
 299
 300             if ((cbp | motion_x | motion_y | mb_type) ==0) {
 301                 /* direct MB with MV={0,0} */
 302                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
 303                 s->misc_bits++;
 304                 s->last_bits++;
 305                 s->skip_count++;
 306                 return;
 307             }
 308             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
 309             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
 310             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
 311             if(cbp) put_bits(&s->pb, 6, cbp);
 312
 313             if(cbp && mb_type)
 314                 put_bits(&s->pb, 1, 0); /* no q-scale change */
 315
 316             bits= get_bit_count(&s->pb);
 317             s->misc_bits+= bits - s->last_bits;
 318             s->last_bits=bits;
 319
 320             switch(mb_type)
 321             {
 322             case 0: /* direct */
 323                 h263_encode_motion(s, motion_x, 1);
 324                 h263_encode_motion(s, motion_y, 1);
 325                 break;
 326             case 1: /* bidir */
 327                 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
 328                 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
 329                 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
 330                 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
 331                 s->last_mv[0][0][0]= s->mv[0][0][0];
 332                 s->last_mv[0][0][1]= s->mv[0][0][1];
 333                 s->last_mv[1][0][0]= s->mv[1][0][0];
 334                 s->last_mv[1][0][1]= s->mv[1][0][1];
 335                 break;
 336             case 2: /* backward */
 337                 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
 338                 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
 339                 s->last_mv[1][0][0]= motion_x;
 340                 s->last_mv[1][0][1]= motion_y;
 341                 break;
 342             case 3: /* forward */
 343                 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
 344                 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
 345                 s->last_mv[0][0][0]= motion_x;
 346                 s->last_mv[0][0][1]= motion_y;
 347                 break;
 348             default:
 349                 printf("unknown mb type\n");
 350                 return;
 351             }
 352             bits= get_bit_count(&s->pb);
 353             s->mv_bits+= bits - s->last_bits;
 354             s->last_bits=bits;
 355
 356             /* encode each block */
 357             for (i = 0; i < 6; i++) {
 358                 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
 359             }
 360             bits= get_bit_count(&s->pb);
 361             s->p_tex_bits+= bits - s->last_bits;
 362             s->last_bits=bits;
 363         }else{ /* s->pict_type==B_TYPE */
 364             if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
 365                 /* check if the B frames can skip it too, as we must skip it if we skip here
 366                    why didnt they just compress the skip-mb bits instead of reusing them ?! */
 367                 if(s->max_b_frames>0){
 368                     int i;
 369                     int x,y, offset;
 370                     uint8_t *p_pic;
 371
 372                     x= s->mb_x*16;
 373                     y= s->mb_y*16;
 374                     if(x+16 > s->width)  x= s->width-16;
 375                     if(y+16 > s->height) y= s->height-16;
 376
 377                     offset= x + y*s->linesize;
 378                     p_pic= s->new_picture[0] + offset;
 379
 380                     s->mb_skiped=1;
 381                     for(i=0; i<s->max_b_frames; i++){
 382                         uint8_t *b_pic;
 383                         int diff;
 384
 385                         if(s->coded_order[i+1].pict_type!=B_TYPE) break;
 386
 387                         b_pic= s->coded_order[i+1].picture[0] + offset;
 388                         diff= pix_abs16x16(p_pic, b_pic, s->linesize);
 389                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
 390                             s->mb_skiped=0;
 391                             break;
 392                         }
 393                     }
 394                 }else
 395                     s->mb_skiped=1;
 396
 397                 if(s->mb_skiped==1){
 398                     /* skip macroblock */
 399                     put_bits(&s->pb, 1, 1);
 400                     s->misc_bits++;
 401                     s->last_bits++;
 402                     s->skip_count++;
 403                     return;
 404                 }
 405             }
 406
 407             put_bits(&s->pb, 1, 0);     /* mb coded */
 408             if(s->mv_type==MV_TYPE_16X16){
 409                 cbpc = cbp & 3;
 410                 put_bits(&s->pb,
 411                         inter_MCBPC_bits[cbpc],
 412                         inter_MCBPC_code[cbpc]);
 413                 cbpy = cbp >> 2;
 414                 cbpy ^= 0xf;
 415                 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 416
 417                 bits= get_bit_count(&s->pb);
 418                 s->misc_bits+= bits - s->last_bits;
 419                 s->last_bits=bits;
 420
 421                 /* motion vectors: 16x16 mode */
 422                 h263_pred_motion(s, 0, &pred_x, &pred_y);
 423
 424                 h263_encode_motion(s, motion_x - pred_x, s->f_code);
 425                 h263_encode_motion(s, motion_y - pred_y, s->f_code);
 426             }else{
 427                 cbpc = (cbp & 3)+16;
 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(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 434
 435                 bits= get_bit_count(&s->pb);
 436                 s->misc_bits+= bits - s->last_bits;
 437                 s->last_bits=bits;
 438
 439                 for(i=0; i<4; i++){
 440                     /* motion vectors: 8x8 mode*/
 441                     h263_pred_motion(s, i, &pred_x, &pred_y);
 442
 443                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
 444                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
 445                 }
 446             }
 447             bits= get_bit_count(&s->pb);
 448             s->mv_bits+= bits - s->last_bits;
 449             s->last_bits=bits;
 450
 451             /* encode each block */
 452             for (i = 0; i < 6; i++) {
 453                 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
 454             }
 455             bits= get_bit_count(&s->pb);
 456             s->p_tex_bits+= bits - s->last_bits;
 457             s->last_bits=bits;
 458             s->p_count++;
 459         }
 460     } else {
 461         int cbp;
 462         int dc_diff[6];   //dc values with the dc prediction subtracted
 463         int dir[6];  //prediction direction
 464         int zigzag_last_index[6];
 465         UINT8 *scan_table[6];
 466
 467         for(i=0; i<6; i++){
 468             const int level= block[i][0];
 469             UINT16 *dc_ptr;
 470
 471             dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
 472             if (i < 4) {
 473                 *dc_ptr = level * s->y_dc_scale;
 474             } else {
 475                 *dc_ptr = level * s->c_dc_scale;
 476             }
 477         }
 478
 479         s->ac_pred= decide_ac_pred(s, block, dir);
 480
 481         if(s->ac_pred){
 482             for(i=0; i<6; i++){
 483                 UINT8 *st;
 484                 int last_index;
 485
 486                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
 487                 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
 488                 else           st = ff_alternate_horizontal_scan; /* top */
 489
 490                 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
 491                     if(block[i][st[last_index]]) break;
 492                 zigzag_last_index[i]= s->block_last_index[i];
 493                 s->block_last_index[i]= last_index;
 494                 scan_table[i]= st;
 495             }
 496         }else{
 497             for(i=0; i<6; i++)
 498                 scan_table[i]= zigzag_direct;
 499         }
 500
 501         /* compute cbp */
 502         cbp = 0;
 503         for (i = 0; i < 6; i++) {
 504             if (s->block_last_index[i] >= 1)
 505                 cbp |= 1 << (5 - i);
 506         }
 507
 508         cbpc = cbp & 3;
 509         if (s->pict_type == I_TYPE) {
 510             put_bits(&s->pb,
 511                 intra_MCBPC_bits[cbpc],
 512                 intra_MCBPC_code[cbpc]);
 513         } else {
 514             put_bits(&s->pb, 1, 0);     /* mb coded */
 515             put_bits(&s->pb,
 516                 inter_MCBPC_bits[cbpc + 4],
 517                 inter_MCBPC_code[cbpc + 4]);
 518         }
 519         put_bits(&s->pb, 1, s->ac_pred);
 520         cbpy = cbp >> 2;
 521         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 522
 523         bits= get_bit_count(&s->pb);
 524         s->misc_bits+= bits - s->last_bits;
 525         s->last_bits=bits;
 526
 527         /* encode each block */
 528         for (i = 0; i < 6; i++) {
 529             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
 530         }
 531
 532         bits= get_bit_count(&s->pb);
 533         s->i_tex_bits+= bits - s->last_bits;
 534         s->last_bits=bits;
 535         s->i_count++;
 536
 537         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
 538         if(s->ac_pred){
 539             for(i=0; i<6; i++){
 540                 int j;
 541                 INT16 *ac_val;
 542
 543                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
 544
 545                 if(dir[i]){
 546                     for(j=1; j<8; j++)
 547                         block[i][block_permute_op(j   )]= ac_val[j+8];
 548                 }else{
 549                     for(j=1; j<8; j++)
 550                         block[i][block_permute_op(j<<3)]= ac_val[j  ];
 551                 }
 552                 s->block_last_index[i]= zigzag_last_index[i];
 553             }
 554         }
 555     }
 556 }
 557
 558 void h263_encode_mb(MpegEncContext * s,
 559                     DCTELEM block[6][64],
 560                     int motion_x, int motion_y)
 561 {
 562     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 563     INT16 pred_dc;
 564     INT16 rec_intradc[6];
 565     UINT16 *dc_ptr[6];
 566
 567     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 568     if (!s->mb_intra) {
 569         /* compute cbp */
 570         cbp = 0;
 571         for (i = 0; i < 6; i++) {
 572             if (s->block_last_index[i] >= 0)
 573                 cbp |= 1 << (5 - i);
 574         }
 575         if ((cbp | motion_x | motion_y) == 0) {
 576             /* skip macroblock */
 577             put_bits(&s->pb, 1, 1);
 578             return;
 579         }
 580         put_bits(&s->pb, 1, 0); /* mb coded */
 581         cbpc = cbp & 3;
 582         put_bits(&s->pb,
 583                     inter_MCBPC_bits[cbpc],
 584                     inter_MCBPC_code[cbpc]);
 585         cbpy = cbp >> 2;
 586         cbpy ^= 0xf;
 587         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 588
 589         /* motion vectors: 16x16 mode only now */
 590         h263_pred_motion(s, 0, &pred_x, &pred_y);
 591
 592         if (!s->umvplus) {
 593             h263_encode_motion(s, motion_x - pred_x, s->f_code);
 594             h263_encode_motion(s, motion_y - pred_y, s->f_code);
 595         }
 596         else {
 597             h263p_encode_umotion(s, motion_x - pred_x);
 598             h263p_encode_umotion(s, motion_y - pred_y);
 599             if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 600                 /* To prevent Start Code emulation */
 601                 put_bits(&s->pb,1,1);
 602         }
 603     } else {
 604         int li = s->h263_aic ? 0 : 1;
 605
 606         cbp = 0;
 607         for(i=0; i<6; i++) {
 608             /* Predict DC */
 609             if (s->h263_aic && s->mb_intra) {
 610                 INT16 level = block[i][0];
 611
 612                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
 613                 level -= pred_dc;
 614                 /* Quant */
 615                 if (level < 0)
 616                     level = (level + (s->qscale >> 1))/(s->y_dc_scale);
 617                 else
 618                     level = (level - (s->qscale >> 1))/(s->y_dc_scale);
 619
 620                 /* AIC can change CBP */
 621                 if (level == 0 && s->block_last_index[i] == 0)
 622                     s->block_last_index[i] = -1;
 623                 else if (level < -127)
 624                     level = -127;
 625                 else if (level > 127)
 626                     level = 127;
 627
 628                 block[i][0] = level;
 629                 /* Reconstruction */
 630                 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
 631                 /* Oddify */
 632                 rec_intradc[i] |= 1;
 633                 //if ((rec_intradc[i] % 2) == 0)
 634                 //    rec_intradc[i]++;
 635                 /* Clipping */
 636                 if (rec_intradc[i] < 0)
 637                     rec_intradc[i] = 0;
 638                 else if (rec_intradc[i] > 2047)
 639                     rec_intradc[i] = 2047;
 640
 641                 /* Update AC/DC tables */
 642                 *dc_ptr[i] = rec_intradc[i];
 643             }
 644             /* compute cbp */
 645             if (s->block_last_index[i] >= li)
 646                 cbp |= 1 << (5 - i);
 647         }
 648
 649         cbpc = cbp & 3;
 650         if (s->pict_type == I_TYPE) {
 651             put_bits(&s->pb,
 652                 intra_MCBPC_bits[cbpc],
 653                 intra_MCBPC_code[cbpc]);
 654         } else {
 655             put_bits(&s->pb, 1, 0);     /* mb coded */
 656             put_bits(&s->pb,
 657                 inter_MCBPC_bits[cbpc + 4],
 658                 inter_MCBPC_code[cbpc + 4]);
 659         }
 660         if (s->h263_aic) {
 661             /* XXX: currently, we do not try to use ac prediction */
 662             put_bits(&s->pb, 1, 0);     /* no AC prediction */
 663         }
 664         cbpy = cbp >> 2;
 665         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 666     }
 667
 668     for(i=0; i<6; i++) {
 669         /* encode each block */
 670         h263_encode_block(s, block[i], i);
 671
 672         /* Update INTRADC for decoding */
 673         if (s->h263_aic && s->mb_intra) {
 674             block[i][0] = rec_intradc[i];
 675
 676         }
 677     }
 678 }
 679
 680 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
 681 {
 682     int x, y, wrap, a, c, pred_dc, scale;
 683     INT16 *dc_val, *ac_val;
 684
 685     /* find prediction */
 686     if (n < 4) {
 687         x = 2 * s->mb_x + 1 + (n & 1);
 688         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 689         wrap = s->mb_width * 2 + 2;
 690         dc_val = s->dc_val[0];
 691         ac_val = s->ac_val[0][0];
 692         scale = s->y_dc_scale;
 693     } else {
 694         x = s->mb_x + 1;
 695         y = s->mb_y + 1;
 696         wrap = s->mb_width + 2;
 697         dc_val = s->dc_val[n - 4 + 1];
 698         ac_val = s->ac_val[n - 4 + 1][0];
 699         scale = s->c_dc_scale;
 700     }
 701     /* B C
 702      * A X
 703      */
 704     a = dc_val[(x - 1) + (y) * wrap];
 705     c = dc_val[(x) + (y - 1) * wrap];
 706
 707     /* No prediction outside GOB boundary */
 708     if (s->first_gob_line && ((n < 2) || (n > 3)))
 709         c = 1024;
 710     pred_dc = 1024;
 711     /* just DC prediction */
 712     if (a != 1024 && c != 1024)
 713         pred_dc = (a + c) >> 1;
 714     else if (a != 1024)
 715         pred_dc = a;
 716     else
 717         pred_dc = c;
 718
 719     /* we assume pred is positive */
 720     //pred_dc = (pred_dc + (scale >> 1)) / scale;
 721     *dc_val_ptr = &dc_val[x + y * wrap];
 722     return pred_dc;
 723 }
 724
 725
 726 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
 727 {
 728     int x, y, wrap, a, c, pred_dc, scale, i;
 729     INT16 *dc_val, *ac_val, *ac_val1;
 730
 731     /* find prediction */
 732     if (n < 4) {
 733         x = 2 * s->mb_x + 1 + (n & 1);
 734         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 735         wrap = s->mb_width * 2 + 2;
 736         dc_val = s->dc_val[0];
 737         ac_val = s->ac_val[0][0];
 738         scale = s->y_dc_scale;
 739     } else {
 740         x = s->mb_x + 1;
 741         y = s->mb_y + 1;
 742         wrap = s->mb_width + 2;
 743         dc_val = s->dc_val[n - 4 + 1];
 744         ac_val = s->ac_val[n - 4 + 1][0];
 745         scale = s->c_dc_scale;
 746     }
 747
 748     ac_val += ((y) * wrap + (x)) * 16;
 749     ac_val1 = ac_val;
 750
 751     /* B C
 752      * A X
 753      */
 754     a = dc_val[(x - 1) + (y) * wrap];
 755     c = dc_val[(x) + (y - 1) * wrap];
 756
 757     /* No prediction outside GOB boundary */
 758     if (s->first_gob_line && ((n < 2) || (n > 3)))
 759         c = 1024;
 760     pred_dc = 1024;
 761     if (s->ac_pred) {
 762         if (s->h263_aic_dir) {
 763             /* left prediction */
 764             if (a != 1024) {
 765                 ac_val -= 16;
 766                 for(i=1;i<8;i++) {
 767                     block[block_permute_op(i*8)] += ac_val[i];
 768                 }
 769                 pred_dc = a;
 770             }
 771         } else {
 772             /* top prediction */
 773             if (c != 1024) {
 774                 ac_val -= 16 * wrap;
 775                 for(i=1;i<8;i++) {
 776                     block[block_permute_op(i)] += ac_val[i + 8];
 777                 }
 778                 pred_dc = c;
 779             }
 780         }
 781     } else {
 782         /* just DC prediction */
 783         if (a != 1024 && c != 1024)
 784             pred_dc = (a + c) >> 1;
 785         else if (a != 1024)
 786             pred_dc = a;
 787         else
 788             pred_dc = c;
 789     }
 790
 791     /* we assume pred is positive */
 792     block[0]=block[0]*scale + pred_dc;
 793
 794     if (block[0] < 0)
 795         block[0] = 0;
 796     else if (!(block[0] & 1))
 797         block[0]++;
 798
 799     /* Update AC/DC tables */
 800     dc_val[(x) + (y) * wrap] = block[0];
 801
 802     /* left copy */
 803     for(i=1;i<8;i++)
 804         ac_val1[i] = block[block_permute_op(i * 8)];
 805     /* top copy */
 806     for(i=1;i<8;i++)
 807         ac_val1[8 + i] = block[block_permute_op(i)];
 808 }
 809
 810 INT16 *h263_pred_motion(MpegEncContext * s, int block,
 811                         int *px, int *py)
 812 {
 813     int xy, wrap;
 814     INT16 *A, *B, *C, *mot_val;
 815     static const int off[4]= {2, 1, 1, -1};
 816
 817     wrap = s->block_wrap[0];
 818     xy = s->block_index[block];
 819
 820     mot_val = s->motion_val[xy];
 821
 822     /* special case for first line */
 823     if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
 824         A = s->motion_val[xy - 1];
 825         *px = A[0];
 826         *py = A[1];
 827     } else {
 828         A = s->motion_val[xy - 1];
 829         B = s->motion_val[xy - wrap];
 830         C = s->motion_val[xy + off[block] - wrap];
 831         *px = mid_pred(A[0], B[0], C[0]);
 832         *py = mid_pred(A[1], B[1], C[1]);
 833     }
 834     return mot_val;
 835 }
 836
 837 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
 838 {
 839     int range, l, m, bit_size, sign, code, bits;
 840
 841     if (val == 0) {
 842         /* zero vector */
 843         code = 0;
 844         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 845     } else {
 846         bit_size = f_code - 1;
 847         range = 1 << bit_size;
 848         /* modulo encoding */
 849         l = range * 32;
 850         m = 2 * l;
 851         if (val < -l) {
 852             val += m;
 853         } else if (val >= l) {
 854             val -= m;
 855         }
 856
 857         if (val >= 0) {
 858             sign = 0;
 859         } else {
 860             val = -val;
 861             sign = 1;
 862         }
 863         val--;
 864         code = (val >> bit_size) + 1;
 865         bits = val & (range - 1);
 866
 867         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 868         if (bit_size > 0) {
 869             put_bits(&s->pb, bit_size, bits);
 870         }
 871     }
 872 }
 873
 874 /* Encode MV differences on H.263+ with Unrestricted MV mode */
 875 static void h263p_encode_umotion(MpegEncContext * s, int val)
 876 {
 877     short sval = 0;
 878     short i = 0;
 879     short n_bits = 0;
 880     short temp_val;
 881     int code = 0;
 882     int tcode;
 883
 884     if ( val == 0)
 885         put_bits(&s->pb, 1, 1);
 886     else if (val == 1)
 887         put_bits(&s->pb, 3, 0);
 888     else if (val == -1)
 889         put_bits(&s->pb, 3, 2);
 890     else {
 891
 892         sval = ((val < 0) ? (short)(-val):(short)val);
 893         temp_val = sval;
 894
 895         while (temp_val != 0) {
 896             temp_val = temp_val >> 1;
 897             n_bits++;
 898         }
 899
 900         i = n_bits - 1;
 901         while (i > 0) {
 902             tcode = (sval & (1 << (i-1))) >> (i-1);
 903             tcode = (tcode << 1) | 1;
 904             code = (code << 2) | tcode;
 905             i--;
 906         }
 907         code = ((code << 1) | (val < 0)) << 1;
 908         put_bits(&s->pb, (2*n_bits)+1, code);
 909         //printf("\nVal = %d\tCode = %d", sval, code);
 910     }
 911 }
 912
 913 static void init_mv_penalty_and_fcode(MpegEncContext *s)
 914 {
 915     int f_code;
 916     int mv;
 917     for(f_code=1; f_code<=MAX_FCODE; f_code++){
 918         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 919             int len;
 920
 921             if(mv==0) len= mvtab[0][1];
 922             else{
 923                 int val, bit_size, range, code;
 924
 925                 bit_size = s->f_code - 1;
 926                 range = 1 << bit_size;
 927
 928                 val=mv;
 929                 if (val < 0)
 930                     val = -val;
 931                 val--;
 932                 code = (val >> bit_size) + 1;
 933                 if(code<33){
 934                     len= mvtab[code][1] + 1 + bit_size;
 935                 }else{
 936                     len= mvtab[32][1] + 2 + bit_size;
 937                 }
 938             }
 939
 940             mv_penalty[f_code][mv+MAX_MV]= len;
 941         }
 942     }
 943
 944     for(f_code=MAX_FCODE; f_code>0; f_code--){
 945         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
 946             fcode_tab[mv+MAX_MV]= f_code;
 947         }
 948     }
 949
 950     for(mv=0; mv<MAX_MV*2+1; mv++){
 951         umv_fcode_tab[mv]= 1;
 952     }
 953 }
 954
 955 static void init_uni_dc_tab()
 956 {
 957     int level, uni_code, uni_len;
 958
 959     for(level=-256; level<256; level++){
 960         int size, v, l;
 961         /* find number of bits */
 962         size = 0;
 963         v = abs(level);
 964         while (v) {
 965             v >>= 1;
 966             size++;
 967         }
 968
 969         if (level < 0)
 970             l= (-level) ^ ((1 << size) - 1);
 971         else
 972             l= level;
 973
 974         /* luminance */
 975         uni_code= DCtab_lum[size][0];
 976         uni_len = DCtab_lum[size][1];
 977
 978         if (size > 0) {
 979             uni_code<<=size; uni_code|=l;
 980             uni_len+=size;
 981             if (size > 8){
 982                 uni_code<<=1; uni_code|=1;
 983                 uni_len++;
 984             }
 985         }
 986         uni_DCtab_lum[level+256][0]= uni_code;
 987         uni_DCtab_lum[level+256][1]= uni_len;
 988
 989         /* chrominance */
 990         uni_code= DCtab_chrom[size][0];
 991         uni_len = DCtab_chrom[size][1];
 992
 993         if (size > 0) {
 994             uni_code<<=size; uni_code|=l;
 995             uni_len+=size;
 996             if (size > 8){
 997                 uni_code<<=1; uni_code|=1;
 998                 uni_len++;
 999             }
1000         }
1001         uni_DCtab_chrom[level+256][0]= uni_code;
1002         uni_DCtab_chrom[level+256][1]= uni_len;
1003
1004     }
1005 }
1006
1007 void h263_encode_init(MpegEncContext *s)
1008 {
1009     static int done = 0;
1010
1011     if (!done) {
1012         done = 1;
1013
1014         init_uni_dc_tab();
1015
1016         init_rl(&rl_inter);
1017         init_rl(&rl_intra);
1018         init_rl(&rl_intra_aic);
1019
1020         init_mv_penalty_and_fcode(s);
1021     }
1022     s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1023
1024     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1025     switch(s->codec_id){
1026     case CODEC_ID_MPEG4:
1027         s->fcode_tab= fcode_tab;
1028         s->min_qcoeff= -2048;
1029         s->max_qcoeff=  2047;
1030         break;
1031     case CODEC_ID_H263P:
1032         s->fcode_tab= umv_fcode_tab;
1033         s->min_qcoeff= -128;
1034         s->max_qcoeff=  127;
1035         break;
1036     default: //nothing needed default table allready set in mpegvideo.c
1037         s->min_qcoeff= -128;
1038         s->max_qcoeff=  127;
1039     }
1040
1041     /* h263 type bias */
1042     //FIXME mpeg4 mpeg quantizer
1043     s->intra_quant_bias=0;
1044     s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1045 }
1046
1047 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1048 {
1049     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1050     RLTable *rl;
1051
1052     rl = &rl_inter;
1053     if (s->mb_intra && !s->h263_aic) {
1054         /* DC coef */
1055             level = block[0];
1056         /* 255 cannot be represented, so we clamp */
1057         if (level > 254) {
1058             level = 254;
1059             block[0] = 254;
1060         }
1061         /* 0 cannot be represented also */
1062         else if (!level) {
1063             level = 1;
1064             block[0] = 1;
1065         }
1066             if (level == 128)
1067                 put_bits(&s->pb, 8, 0xff);
1068             else
1069                 put_bits(&s->pb, 8, level & 0xff);
1070             i = 1;
1071     } else {
1072             i = 0;
1073             if (s->h263_aic && s->mb_intra)
1074                 rl = &rl_intra_aic;
1075     }
1076
1077     /* AC coefs */
1078     last_index = s->block_last_index[n];
1079     last_non_zero = i - 1;
1080     for (; i <= last_index; i++) {
1081         j = zigzag_direct[i];
1082         level = block[j];
1083         if (level) {
1084             run = i - last_non_zero - 1;
1085             last = (i == last_index);
1086             sign = 0;
1087             slevel = level;
1088             if (level < 0) {
1089                 sign = 1;
1090                 level = -level;
1091             }
1092             code = get_rl_index(rl, last, run, level);
1093             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1094             if (code == rl->n) {
1095                 put_bits(&s->pb, 1, last);
1096                 put_bits(&s->pb, 6, run);
1097                 put_bits(&s->pb, 8, slevel & 0xff);
1098             } else {
1099                 put_bits(&s->pb, 1, sign);
1100             }
1101                 last_non_zero = i;
1102             }
1103     }
1104 }
1105
1106 /***************************************************/
1107
1108 static void mpeg4_stuffing(PutBitContext * pbc)
1109 {
1110     int length;
1111     put_bits(pbc, 1, 0);
1112     length= (-get_bit_count(pbc))&7;
1113     put_bits(pbc, length, (1<<length)-1);
1114 }
1115
1116 /* must be called before writing the header */
1117 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1118     int time_div, time_mod;
1119
1120     if(s->pict_type==I_TYPE){ //we will encode a vol header
1121         s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1122         if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1123
1124         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1125     }
1126
1127     s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1128     time_div= s->time/s->time_increment_resolution;
1129     time_mod= s->time%s->time_increment_resolution;
1130
1131     if(s->pict_type==B_TYPE){
1132         s->bp_time= s->last_non_b_time - s->time;
1133     }else{
1134         s->last_time_base= s->time_base;
1135         s->time_base= time_div;
1136         s->pp_time= s->time - s->last_non_b_time;
1137         s->last_non_b_time= s->time;
1138     }
1139 }
1140
1141 static void mpeg4_encode_vol_header(MpegEncContext * s)
1142 {
1143     int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1144     char buf[255];
1145
1146     s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1147
1148     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1149     put_bits(&s->pb, 16, 0);
1150     put_bits(&s->pb, 16, 0x100);        /* video obj */
1151     put_bits(&s->pb, 16, 0);
1152     put_bits(&s->pb, 16, 0x120);        /* video obj layer */
1153
1154     put_bits(&s->pb, 1, 0);             /* random access vol */
1155     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
1156     put_bits(&s->pb, 1, 1);             /* is obj layer id= yes */
1157       put_bits(&s->pb, 4, vo_ver_id);   /* is obj layer ver id */
1158       put_bits(&s->pb, 3, 1);           /* is obj layer priority */
1159     if(s->aspect_ratio_info)
1160         put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1161     else
1162         put_bits(&s->pb, 4, 1);         /* aspect ratio info= sqare pixel */
1163
1164     if(s->low_delay){
1165         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
1166         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
1167         put_bits(&s->pb, 1, s->low_delay);
1168         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
1169     }else{
1170         put_bits(&s->pb, 1, 0);         /* vol control parameters= no */
1171     }
1172
1173     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
1174     put_bits(&s->pb, 1, 1);             /* marker bit */
1175
1176     put_bits(&s->pb, 16, s->time_increment_resolution);
1177     if (s->time_increment_bits < 1)
1178         s->time_increment_bits = 1;
1179     put_bits(&s->pb, 1, 1);             /* marker bit */
1180     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
1181     put_bits(&s->pb, 1, 1);             /* marker bit */
1182     put_bits(&s->pb, 13, s->width);     /* vol width */
1183     put_bits(&s->pb, 1, 1);             /* marker bit */
1184     put_bits(&s->pb, 13, s->height);    /* vol height */
1185     put_bits(&s->pb, 1, 1);             /* marker bit */
1186     put_bits(&s->pb, 1, 0);             /* interlace */
1187     put_bits(&s->pb, 1, 1);             /* obmc disable */
1188     if (vo_ver_id == 1) {
1189         put_bits(&s->pb, 1, s->vol_sprite_usage=0);             /* sprite enable */
1190     }else{ /* vo_ver_id == 2 */
1191         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
1192     }
1193     put_bits(&s->pb, 1, 0);             /* not 8 bit */
1194     put_bits(&s->pb, 1, 0);             /* quant type= h263 style*/
1195     if (vo_ver_id != 1)
1196         put_bits(&s->pb, 1, s->quarter_sample=0);
1197     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
1198     put_bits(&s->pb, 1, 1);             /* resync marker disable */
1199     put_bits(&s->pb, 1, 0);             /* data partitioned */
1200     if (vo_ver_id != 1){
1201         put_bits(&s->pb, 1, 0);         /* newpred */
1202         put_bits(&s->pb, 1, 0);         /* reduced res vop */
1203     }
1204     put_bits(&s->pb, 1, 0);             /* scalability */
1205
1206     mpeg4_stuffing(&s->pb);
1207     put_bits(&s->pb, 16, 0);
1208     put_bits(&s->pb, 16, 0x1B2);        /* user_data */
1209     sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1210     put_string(&s->pb, buf);
1211
1212     s->no_rounding = 0;
1213 }
1214
1215 /* write mpeg4 VOP header */
1216 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1217 {
1218     int time_incr;
1219     int time_div, time_mod;
1220
1221     if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
1222
1223 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1224
1225     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
1226     put_bits(&s->pb, 16, 0);            /* vop header */
1227     put_bits(&s->pb, 16, 0x1B6);        /* vop header */
1228     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
1229
1230     time_div= s->time/s->time_increment_resolution;
1231     time_mod= s->time%s->time_increment_resolution;
1232     time_incr= time_div - s->last_time_base;
1233     while(time_incr--)
1234         put_bits(&s->pb, 1, 1);
1235
1236     put_bits(&s->pb, 1, 0);
1237
1238     put_bits(&s->pb, 1, 1);     /* marker */
1239     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1240     put_bits(&s->pb, 1, 1);     /* marker */
1241     put_bits(&s->pb, 1, 1);     /* vop coded */
1242     if (    s->pict_type == P_TYPE
1243         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1244         s->no_rounding ^= 1;
1245         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
1246     }
1247     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
1248     //FIXME sprite stuff
1249
1250     put_bits(&s->pb, 5, s->qscale);
1251
1252     if (s->pict_type != I_TYPE)
1253         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1254     if (s->pict_type == B_TYPE)
1255         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1256     //    printf("****frame %d\n", picture_number);
1257 }
1258
1259 void h263_dc_scale(MpegEncContext * s)
1260 {
1261 #if 1
1262     const static UINT8 y_tab[32]={
1263     //  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
1264         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
1265     };
1266     const static UINT8 c_tab[32]={
1267     //  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
1268         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
1269     };
1270     s->y_dc_scale = y_tab[s->qscale];
1271     s->c_dc_scale = c_tab[s->qscale];
1272 #else
1273     int quant;
1274     quant = s->qscale;
1275     /* luminance */
1276     if (quant < 5)
1277         s->y_dc_scale = 8;
1278     else if (quant > 4 && quant < 9)
1279         s->y_dc_scale = (2 * quant);
1280     else if (quant > 8 && quant < 25)
1281         s->y_dc_scale = (quant + 8);
1282     else
1283         s->y_dc_scale = (2 * quant - 16);
1284     /* chrominance */
1285     if (quant < 5)
1286         s->c_dc_scale = 8;
1287     else if (quant > 4 && quant < 25)
1288         s->c_dc_scale = ((quant + 13) / 2);
1289     else
1290         s->c_dc_scale = (quant - 6);
1291 #endif
1292 }
1293
1294 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1295 {
1296     int a, b, c, wrap, pred, scale;
1297     UINT16 *dc_val;
1298     int dummy;
1299
1300     /* find prediction */
1301     if (n < 4) {
1302         scale = s->y_dc_scale;
1303     } else {
1304         scale = s->c_dc_scale;
1305     }
1306     wrap= s->block_wrap[n];
1307     dc_val = s->dc_val[0] + s->block_index[n];
1308
1309     /* B C
1310      * A X
1311      */
1312     a = dc_val[ - 1];
1313     b = dc_val[ - 1 - wrap];
1314     c = dc_val[ - wrap];
1315
1316     if (abs(a - b) < abs(b - c)) {
1317         pred = c;
1318         *dir_ptr = 1; /* top */
1319     } else {
1320         pred = a;
1321         *dir_ptr = 0; /* left */
1322     }
1323     /* we assume pred is positive */
1324 #ifdef ARCH_X86
1325         asm volatile (
1326                 "xorl %%edx, %%edx      \n\t"
1327                 "mul %%ecx              \n\t"
1328                 : "=d" (pred), "=a"(dummy)
1329                 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1330         );
1331 #else
1332     pred = (pred + (scale >> 1)) / scale;
1333 #endif
1334
1335     /* prepare address for prediction update */
1336     *dc_val_ptr = &dc_val[0];
1337
1338     return pred;
1339 }
1340
1341 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1342                    int dir)
1343 {
1344     int i;
1345     INT16 *ac_val, *ac_val1;
1346
1347     /* find prediction */
1348     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1349     ac_val1 = ac_val;
1350     if (s->ac_pred) {
1351         if (dir == 0) {
1352             /* left prediction */
1353             ac_val -= 16;
1354             for(i=1;i<8;i++) {
1355                 block[block_permute_op(i*8)] += ac_val[i];
1356             }
1357         } else {
1358             /* top prediction */
1359             ac_val -= 16 * s->block_wrap[n];
1360             for(i=1;i<8;i++) {
1361                 block[block_permute_op(i)] += ac_val[i + 8];
1362             }
1363         }
1364     }
1365     /* left copy */
1366     for(i=1;i<8;i++)
1367         ac_val1[i] = block[block_permute_op(i * 8)];
1368     /* top copy */
1369     for(i=1;i<8;i++)
1370         ac_val1[8 + i] = block[block_permute_op(i)];
1371 }
1372
1373 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1374                               int dir)
1375 {
1376     int i;
1377     INT16 *ac_val;
1378
1379     /* find prediction */
1380     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1381
1382     if (dir == 0) {
1383         /* left prediction */
1384         ac_val -= 16;
1385         for(i=1;i<8;i++) {
1386             block[block_permute_op(i*8)] -= ac_val[i];
1387         }
1388     } else {
1389         /* top prediction */
1390         ac_val -= 16 * s->block_wrap[n];
1391         for(i=1;i<8;i++) {
1392             block[block_permute_op(i)] -= ac_val[i + 8];
1393         }
1394     }
1395 }
1396
1397 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1398 {
1399 #if 1
1400     level+=256;
1401     if (n < 4) {
1402         /* luminance */
1403         put_bits(&s->pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1404     } else {
1405         /* chrominance */
1406         put_bits(&s->pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1407     }
1408 #else
1409     int size, v;
1410     /* find number of bits */
1411     size = 0;
1412     v = abs(level);
1413     while (v) {
1414         v >>= 1;
1415         size++;
1416     }
1417
1418     if (n < 4) {
1419         /* luminance */
1420         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1421     } else {
1422         /* chrominance */
1423         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1424     }
1425
1426     /* encode remaining bits */
1427     if (size > 0) {
1428         if (level < 0)
1429             level = (-level) ^ ((1 << size) - 1);
1430         put_bits(&s->pb, size, level);
1431         if (size > 8)
1432             put_bits(&s->pb, 1, 1);
1433     }
1434 #endif
1435 }
1436
1437 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1438 {
1439     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1440     int code;
1441     const RLTable *rl;
1442
1443     if (s->mb_intra) {
1444         /* mpeg4 based DC predictor */
1445         mpeg4_encode_dc(s, intra_dc, n);
1446         i = 1;
1447         rl = &rl_intra;
1448     } else {
1449         i = 0;
1450         rl = &rl_inter;
1451     }
1452
1453     /* AC coefs */
1454     last_index = s->block_last_index[n];
1455     last_non_zero = i - 1;
1456     for (; i <= last_index; i++) {
1457         j = scan_table[i];
1458         level = block[j];
1459         if (level) {
1460             run = i - last_non_zero - 1;
1461             last = (i == last_index);
1462             sign = 0;
1463             slevel = level;
1464             if (level < 0) {
1465                 sign = 1;
1466                 level = -level;
1467             }
1468             code = get_rl_index(rl, last, run, level);
1469             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1470             if (code == rl->n) {
1471                 int level1, run1;
1472                 level1 = level - rl->max_level[last][run];
1473                 if (level1 < 1)
1474                     goto esc2;
1475                 code = get_rl_index(rl, last, run, level1);
1476                 if (code == rl->n) {
1477                 esc2:
1478                     put_bits(&s->pb, 1, 1);
1479                     if (level > MAX_LEVEL)
1480                         goto esc3;
1481                     run1 = run - rl->max_run[last][level] - 1;
1482                     if (run1 < 0)
1483                         goto esc3;
1484                     code = get_rl_index(rl, last, run1, level);
1485                     if (code == rl->n) {
1486                     esc3:
1487                         /* third escape */
1488                         put_bits(&s->pb, 1, 1);
1489                         put_bits(&s->pb, 1, last);
1490                         put_bits(&s->pb, 6, run);
1491                         put_bits(&s->pb, 1, 1);
1492                         put_bits(&s->pb, 12, slevel & 0xfff);
1493                         put_bits(&s->pb, 1, 1);
1494                     } else {
1495                         /* second escape */
1496                         put_bits(&s->pb, 1, 0);
1497                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1498                         put_bits(&s->pb, 1, sign);
1499                     }
1500                 } else {
1501                     /* first escape */
1502                     put_bits(&s->pb, 1, 0);
1503                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1504                     put_bits(&s->pb, 1, sign);
1505                 }
1506             } else {
1507                 put_bits(&s->pb, 1, sign);
1508             }
1509             last_non_zero = i;
1510         }
1511     }
1512 }
1513
1514
1515
1516 /***********************************************/
1517 /* decoding */
1518
1519 static VLC intra_MCBPC_vlc;
1520 static VLC inter_MCBPC_vlc;
1521 static VLC cbpy_vlc;
1522 static VLC mv_vlc;
1523 static VLC dc_lum, dc_chrom;
1524 static VLC sprite_trajectory;
1525 static VLC mb_type_b_vlc;
1526
1527 void init_rl(RLTable *rl)
1528 {
1529     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1530     UINT8 index_run[MAX_RUN+1];
1531     int last, run, level, start, end, i;
1532
1533     /* compute max_level[], max_run[] and index_run[] */
1534     for(last=0;last<2;last++) {
1535         if (last == 0) {
1536             start = 0;
1537             end = rl->last;
1538         } else {
1539             start = rl->last;
1540             end = rl->n;
1541         }
1542
1543         memset(max_level, 0, MAX_RUN + 1);
1544         memset(max_run, 0, MAX_LEVEL + 1);
1545         memset(index_run, rl->n, MAX_RUN + 1);
1546         for(i=start;i<end;i++) {
1547             run = rl->table_run[i];
1548             level = rl->table_level[i];
1549             if (index_run[run] == rl->n)
1550                 index_run[run] = i;
1551             if (level > max_level[run])
1552                 max_level[run] = level;
1553             if (run > max_run[level])
1554                 max_run[level] = run;
1555         }
1556         rl->max_level[last] = malloc(MAX_RUN + 1);
1557         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1558         rl->max_run[last] = malloc(MAX_LEVEL + 1);
1559         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1560         rl->index_run[last] = malloc(MAX_RUN + 1);
1561         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1562     }
1563 }
1564
1565 void init_vlc_rl(RLTable *rl)
1566 {
1567     init_vlc(&rl->vlc, 9, rl->n + 1,
1568              &rl->table_vlc[0][1], 4, 2,
1569              &rl->table_vlc[0][0], 4, 2);
1570 }
1571
1572 /* init vlcs */
1573
1574 /* XXX: find a better solution to handle static init */
1575 void h263_decode_init_vlc(MpegEncContext *s)
1576 {
1577     static int done = 0;
1578
1579     if (!done) {
1580         done = 1;
1581
1582         init_vlc(&intra_MCBPC_vlc, 6, 8,
1583                  intra_MCBPC_bits, 1, 1,
1584                  intra_MCBPC_code, 1, 1);
1585         init_vlc(&inter_MCBPC_vlc, 9, 25,
1586                  inter_MCBPC_bits, 1, 1,
1587                  inter_MCBPC_code, 1, 1);
1588         init_vlc(&cbpy_vlc, 6, 16,
1589                  &cbpy_tab[0][1], 2, 1,
1590                  &cbpy_tab[0][0], 2, 1);
1591         init_vlc(&mv_vlc, 9, 33,
1592                  &mvtab[0][1], 2, 1,
1593                  &mvtab[0][0], 2, 1);
1594         init_rl(&rl_inter);
1595         init_rl(&rl_intra);
1596         init_rl(&rl_intra_aic);
1597         init_vlc_rl(&rl_inter);
1598         init_vlc_rl(&rl_intra);
1599         init_vlc_rl(&rl_intra_aic);
1600         init_vlc(&dc_lum, 9, 13,
1601                  &DCtab_lum[0][1], 2, 1,
1602                  &DCtab_lum[0][0], 2, 1);
1603         init_vlc(&dc_chrom, 9, 13,
1604                  &DCtab_chrom[0][1], 2, 1,
1605                  &DCtab_chrom[0][0], 2, 1);
1606         init_vlc(&sprite_trajectory, 9, 15,
1607                  &sprite_trajectory_tab[0][1], 4, 2,
1608                  &sprite_trajectory_tab[0][0], 4, 2);
1609         init_vlc(&mb_type_b_vlc, 4, 4,
1610                  &mb_type_b_tab[0][1], 2, 1,
1611                  &mb_type_b_tab[0][0], 2, 1);
1612     }
1613 }
1614
1615 int h263_decode_gob_header(MpegEncContext *s)
1616 {
1617     unsigned int val, gfid;
1618
1619     /* Check for GOB Start Code */
1620     val = show_bits(&s->gb, 16);
1621     if (val == 0) {
1622         /* We have a GBSC probably with GSTUFF */
1623         skip_bits(&s->gb, 16); /* Drop the zeros */
1624         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1625 #ifdef DEBUG
1626         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1627 #endif
1628         s->gob_number = get_bits(&s->gb, 5); /* GN */
1629         gfid = get_bits(&s->gb, 2); /* GFID */
1630         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1631 #ifdef DEBUG
1632         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1633 #endif
1634         return 1;
1635     }
1636     return 0;
1637
1638 }
1639
1640 static inline void memsetw(short *tab, int val, int n)
1641 {
1642     int i;
1643     for(i=0;i<n;i++)
1644         tab[i] = val;
1645 }
1646
1647 static int mpeg4_resync(MpegEncContext *s)
1648 {
1649     int state, v, bits;
1650     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1651     int header_extension=0, mb_num;
1652     int c_wrap, c_xy, l_wrap, l_xy;
1653     int time_increment;
1654 //printf("resync at %d %d\n", s->mb_x, s->mb_y);
1655 //printf("%X\n", show_bits(&s->gb, 24));
1656
1657     if( get_bits_count(&s->gb) > s->gb.size*8-32)
1658         return 0;
1659
1660     align_get_bits(&s->gb);
1661     state = 0xff;
1662     for(;;) {
1663         v = get_bits(&s->gb, 8);
1664 //printf("%X ", v);
1665         state = ((state << 8) | v) & 0xffff;
1666         if (state == 0) break;
1667         if( get_bits_count(&s->gb) > s->gb.size*8-32){
1668             printf("resync failed\n");
1669             return -1;
1670         }
1671     }
1672 //printf("%X\n", show_bits(&s->gb, 24));
1673     bits=0;
1674     while(!get_bits1(&s->gb) && bits<30) bits++;
1675     if(s->pict_type == P_TYPE && bits != s->f_code-1)
1676         printf("marker does not match f_code\n");
1677     //FIXME check bits for B-framess
1678 //printf("%X\n", show_bits(&s->gb, 24));
1679
1680     if(s->shape != RECT_SHAPE){
1681         header_extension= get_bits1(&s->gb);
1682         //FIXME more stuff here
1683     }
1684
1685     mb_num= get_bits(&s->gb, mb_num_bits);
1686     if(mb_num != s->mb_x + s->mb_y*s->mb_width){
1687         printf("MB-num change not supported %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1688 //        s->mb_x= mb_num % s->mb_width;
1689 //        s->mb_y= mb_num / s->mb_width;
1690         //FIXME many vars are wrong now
1691     }
1692
1693     if(s->shape != BIN_ONLY_SHAPE){
1694         s->qscale= get_bits(&s->gb, 5);
1695         h263_dc_scale(s);
1696     }
1697
1698     if(s->shape == RECT_SHAPE){
1699         header_extension= get_bits1(&s->gb);
1700     }
1701     if(header_extension){
1702         int time_incr=0;
1703         printf("header extension not really supported\n");
1704         while (get_bits1(&s->gb) != 0)
1705             time_incr++;
1706
1707         check_marker(&s->gb, "before time_increment in video packed header");
1708         time_increment= get_bits(&s->gb, s->time_increment_bits);
1709         if(s->pict_type!=B_TYPE){
1710             s->last_time_base= s->time_base;
1711             s->time_base+= time_incr;
1712             s->time= s->time_base*s->time_increment_resolution + time_increment;
1713             s->pp_time= s->time - s->last_non_b_time;
1714             s->last_non_b_time= s->time;
1715         }else{
1716             s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1717             s->bp_time= s->last_non_b_time - s->time;
1718         }
1719         check_marker(&s->gb, "before vop_coding_type in video packed header");
1720
1721         skip_bits(&s->gb, 2); /* vop coding type */
1722         //FIXME not rect stuff here
1723
1724         if(s->shape != BIN_ONLY_SHAPE){
1725             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
1726
1727             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1728                 mpeg4_decode_sprite_trajectory(s);
1729             }
1730
1731             //FIXME reduced res stuff here
1732
1733             if (s->pict_type != I_TYPE) {
1734                 s->f_code = get_bits(&s->gb, 3);        /* fcode_for */
1735                 if(s->f_code==0){
1736                     printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1737                     return -1; // makes no sense to continue, as the MV decoding will break very quickly
1738                 }
1739             }
1740             if (s->pict_type == B_TYPE) {
1741                 s->b_code = get_bits(&s->gb, 3);
1742             }
1743         }
1744
1745     }
1746     //FIXME new-pred stuff
1747
1748     l_wrap= s->block_wrap[0];
1749     l_xy= s->mb_y*l_wrap*2;
1750     c_wrap= s->block_wrap[4];
1751     c_xy= s->mb_y*c_wrap;
1752
1753     /* clean DC */
1754     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*3);
1755     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap*2);
1756     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap*2);
1757
1758     /* clean AC */
1759     memset(s->ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16));
1760     memset(s->ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1761     memset(s->ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16));
1762
1763     /* clean MV */
1764     memset(s->motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16));
1765 //    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1766     s->resync_x_pos= s->mb_x;
1767     s->first_slice_line=1;
1768
1769     return 0;
1770 }
1771
1772 int h263_decode_mb(MpegEncContext *s,
1773                    DCTELEM block[6][64])
1774 {
1775     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1776     INT16 *mot_val;
1777     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1778
1779     if(s->mb_x==0) PRINT_MB_TYPE("\n")
1780
1781     if(s->resync_marker){
1782         if(   s->resync_x_pos == s->mb_x+1
1783            || s->resync_x_pos == s->mb_x){
1784             /* f*ck mpeg4
1785                this is here so we dont need to slowdown h263_pred_motion with it */
1786             if(s->resync_x_pos == s->mb_x+1 && s->mb_x==0){
1787                 int xy= s->block_index[0] - s->block_wrap[0];
1788                 s->motion_val[xy][0]= s->motion_val[xy+2][0];
1789                 s->motion_val[xy][1]= s->motion_val[xy+2][1];
1790             }
1791
1792             s->first_slice_line=0;
1793             s->resync_x_pos=0; // isnt needed but for cleanness sake ;)
1794         }
1795
1796         if(show_aligned_bits(&s->gb, 1, 16) == 0){
1797             if( mpeg4_resync(s) < 0 ) return -1;
1798
1799         }
1800     }
1801
1802     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1803         if (get_bits1(&s->gb)) {
1804             /* skip mb */
1805             s->mb_intra = 0;
1806             for(i=0;i<6;i++)
1807                 s->block_last_index[i] = -1;
1808             s->mv_dir = MV_DIR_FORWARD;
1809             s->mv_type = MV_TYPE_16X16;
1810             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1811                 const int a= s->sprite_warping_accuracy;
1812 //                int l = (1 << (s->f_code - 1)) * 32;
1813                 PRINT_MB_TYPE("G");
1814                 s->mcsel=1;
1815                 if(s->divx_version==500 && s->divx_build==413){
1816                     s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1817                     s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1818                 }else{
1819                     s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1820                     s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1821                 }
1822 /*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1823                 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1824                 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1825                 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1826
1827                 s->mb_skiped = 0;
1828             }else{
1829                 PRINT_MB_TYPE("S");
1830                 s->mcsel=0;
1831                 s->mv[0][0][0] = 0;
1832                 s->mv[0][0][1] = 0;
1833                 s->mb_skiped = 1;
1834             }
1835             return 0;
1836         }
1837         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1838         //fprintf(stderr, "\tCBPC: %d", cbpc);
1839         if (cbpc < 0)
1840             return -1;
1841         if (cbpc > 20)
1842             cbpc+=3;
1843         else if (cbpc == 20)
1844             fprintf(stderr, "Stuffing !");
1845
1846         dquant = cbpc & 8;
1847         s->mb_intra = ((cbpc & 4) != 0);
1848         if (s->mb_intra) goto intra;
1849
1850         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1851             s->mcsel= get_bits1(&s->gb);
1852         else s->mcsel= 0;
1853         cbpy = get_vlc(&s->gb, &cbpy_vlc);
1854         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1855         if (dquant) {
1856             s->qscale += quant_tab[get_bits(&s->gb, 2)];
1857             if (s->qscale < 1)
1858                 s->qscale = 1;
1859             else if (s->qscale > 31)
1860                 s->qscale = 31;
1861             h263_dc_scale(s);
1862         }
1863         s->mv_dir = MV_DIR_FORWARD;
1864         if ((cbpc & 16) == 0) {
1865             PRINT_MB_TYPE("P");
1866             /* 16x16 motion prediction */
1867             s->mv_type = MV_TYPE_16X16;
1868             h263_pred_motion(s, 0, &pred_x, &pred_y);
1869             if (s->umvplus_dec)
1870                mx = h263p_decode_umotion(s, pred_x);
1871             else if(!s->mcsel)
1872                mx = h263_decode_motion(s, pred_x, s->f_code);
1873             else {
1874                const int a= s->sprite_warping_accuracy;
1875 //        int l = (1 << (s->f_code - 1)) * 32;
1876                 if(s->divx_version==500 && s->divx_build==413){
1877                     mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
1878                 }else{
1879                     mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1880                 }
1881 //        if (mx < -l) mx= -l, printf("C");
1882 //        else if (mx >= l) mx= l-1, printf("C");
1883             }
1884             if (mx >= 0xffff)
1885                 return -1;
1886
1887             if (s->umvplus_dec)
1888                my = h263p_decode_umotion(s, pred_y);
1889             else if(!s->mcsel)
1890                my = h263_decode_motion(s, pred_y, s->f_code);
1891             else{
1892                const int a= s->sprite_warping_accuracy;
1893 //       int l = (1 << (s->f_code - 1)) * 32;
1894                 if(s->divx_version==500 && s->divx_build==413){
1895                     my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
1896                 }else{
1897                     my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1898                 }
1899 //       if (my < -l) my= -l, printf("C");
1900 //       else if (my >= l) my= l-1, printf("C");
1901             }
1902             if (my >= 0xffff)
1903                 return -1;
1904             s->mv[0][0][0] = mx;
1905             s->mv[0][0][1] = my;
1906             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1907             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1908             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1909             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1910                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1911
1912         } else {
1913             PRINT_MB_TYPE("4");
1914             s->mv_type = MV_TYPE_8X8;
1915             for(i=0;i<4;i++) {
1916                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1917                 if (s->umvplus_dec)
1918                   mx = h263p_decode_umotion(s, pred_x);
1919                 else
1920                   mx = h263_decode_motion(s, pred_x, s->f_code);
1921                 if (mx >= 0xffff)
1922                     return -1;
1923
1924                 if (s->umvplus_dec)
1925                   my = h263p_decode_umotion(s, pred_y);
1926                 else
1927                   my = h263_decode_motion(s, pred_y, s->f_code);
1928                 if (my >= 0xffff)
1929                     return -1;
1930                 s->mv[0][i][0] = mx;
1931                 s->mv[0][i][1] = my;
1932                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1933                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1934                 mot_val[0] = mx;
1935                 mot_val[1] = my;
1936             }
1937         }
1938     } else if(s->pict_type==B_TYPE) {
1939         int modb1; // first bit of modb
1940         int modb2; // second bit of modb
1941         int mb_type;
1942         uint16_t time_pp;
1943         uint16_t time_pb;
1944         int xy;
1945
1946         s->mb_intra = 0; //B-frames never contain intra blocks
1947         s->mcsel=0;      //     ...               true gmc blocks
1948
1949         if(s->mb_x==0){
1950             s->last_mv[0][0][0]=
1951             s->last_mv[0][0][1]=
1952             s->last_mv[1][0][0]=
1953             s->last_mv[1][0][1]= 0;
1954         }
1955
1956         /* if we skipped it in the future P Frame than skip it now too */
1957         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
1958
1959         if(s->mb_skiped){
1960                 /* skip mb */
1961             for(i=0;i<6;i++)
1962                 s->block_last_index[i] = -1;
1963
1964             s->mv_dir = MV_DIR_FORWARD;
1965             s->mv_type = MV_TYPE_16X16;
1966             s->mv[0][0][0] = 0;
1967             s->mv[0][0][1] = 0;
1968             s->mv[1][0][0] = 0;
1969             s->mv[1][0][1] = 0;
1970 //FIXME is this correct?
1971 /*            s->last_mv[0][0][0]=
1972             s->last_mv[0][0][1]=0;*/
1973             PRINT_MB_TYPE("s")
1974             return 0;
1975         }
1976
1977         modb1= get_bits1(&s->gb);
1978         if(modb1==0){
1979             modb2= get_bits1(&s->gb);
1980             mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1981             if(modb2==0) cbp= get_bits(&s->gb, 6);
1982             else cbp=0;
1983             if (mb_type && cbp) {
1984                 if(get_bits1(&s->gb)){
1985                     s->qscale +=get_bits1(&s->gb)*4 - 2;
1986                     if (s->qscale < 1)
1987                         s->qscale = 1;
1988                     else if (s->qscale > 31)
1989                         s->qscale = 31;
1990                     h263_dc_scale(s);
1991                 }
1992             }
1993         }else{
1994             mb_type=4; //like 0 but no vectors coded
1995             cbp=0;
1996         }
1997         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
1998         mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1999         switch(mb_type)
2000         {
2001         case 0: /* direct */
2002             mx = h263_decode_motion(s, 0, 1);
2003             my = h263_decode_motion(s, 0, 1);
2004         case 4: /* direct with mx=my=0 */
2005             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2006             xy= s->block_index[0];
2007             time_pp= s->pp_time;
2008             time_pb= time_pp - s->bp_time;
2009 //if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
2010             //FIXME 4MV
2011             //FIXME avoid divides
2012             s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
2013             s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
2014             s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
2015                                 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
2016             s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
2017                                 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
2018 /*            s->mv[0][0][0] =
2019             s->mv[0][0][1] =
2020             s->mv[1][0][0] =
2021             s->mv[1][0][1] = 1000;*/
2022             PRINT_MB_TYPE("D");
2023             break;
2024         case 1:
2025             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2026             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2027             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2028             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2029             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2030
2031             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2032             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2033             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2034             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2035             PRINT_MB_TYPE("i");
2036             break;
2037         case 2:
2038             s->mv_dir = MV_DIR_BACKWARD;
2039             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2040             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2041             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2042             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2043             PRINT_MB_TYPE("B");
2044             break;
2045         case 3:
2046             s->mv_dir = MV_DIR_FORWARD;
2047             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2048             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2049             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2050             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2051             PRINT_MB_TYPE("F");
2052             break;
2053         default:
2054             printf("illegal MB_type\n");
2055             return -1;
2056         }
2057     } else { /* I-Frame */
2058         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
2059         if (cbpc < 0)
2060             return -1;
2061         dquant = cbpc & 4;
2062         s->mb_intra = 1;
2063 intra:
2064         PRINT_MB_TYPE("I");
2065         s->ac_pred = 0;
2066         if (s->h263_pred || s->h263_aic) {
2067             s->ac_pred = get_bits1(&s->gb);
2068             if (s->ac_pred && s->h263_aic)
2069                 s->h263_aic_dir = get_bits1(&s->gb);
2070         }
2071         if (s->h263_aic) {
2072             s->y_dc_scale = 2 * s->qscale;
2073             s->c_dc_scale = 2 * s->qscale;
2074         }
2075         cbpy = get_vlc(&s->gb, &cbpy_vlc);
2076         cbp = (cbpc & 3) | (cbpy << 2);
2077         if (dquant) {
2078             s->qscale += quant_tab[get_bits(&s->gb, 2)];
2079             if (s->qscale < 1)
2080                 s->qscale = 1;
2081             else if (s->qscale > 31)
2082                 s->qscale = 31;
2083             h263_dc_scale(s);
2084         }
2085     }
2086
2087     /* decode each block */
2088     if (s->h263_pred) {
2089         for (i = 0; i < 6; i++) {
2090             if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2091                 return -1;
2092         }
2093     } else {
2094         for (i = 0; i < 6; i++) {
2095             if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2096                 return -1;
2097         }
2098     }
2099     return 0;
2100 }
2101
2102 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
2103 {
2104     int code, val, sign, shift, l, m;
2105
2106     code = get_vlc(&s->gb, &mv_vlc);
2107     if (code < 0)
2108         return 0xffff;
2109
2110     if (code == 0)
2111         return pred;
2112     sign = get_bits1(&s->gb);
2113     shift = f_code - 1;
2114     val = (code - 1) << shift;
2115     if (shift > 0)
2116         val |= get_bits(&s->gb, shift);
2117     val++;
2118     if (sign)
2119         val = -val;
2120     val += pred;
2121
2122     /* modulo decoding */
2123     if (!s->h263_long_vectors) {
2124         l = (1 << (f_code - 1)) * 32;
2125         m = 2 * l;
2126         if (val < -l) {
2127             val += m;
2128         } else if (val >= l) {
2129             val -= m;
2130         }
2131     } else {
2132         /* horrible h263 long vector mode */
2133         if (pred < -31 && val < -63)
2134             val += 64;
2135         if (pred > 32 && val > 63)
2136             val -= 64;
2137
2138     }
2139     return val;
2140 }
2141
2142 /* Decodes RVLC of H.263+ UMV */
2143 static int h263p_decode_umotion(MpegEncContext * s, int pred)
2144 {
2145    int code = 0, sign;
2146
2147    if (get_bits1(&s->gb)) /* Motion difference = 0 */
2148       return pred;
2149
2150    code = 2 + get_bits1(&s->gb);
2151
2152    while (get_bits1(&s->gb))
2153    {
2154       code <<= 1;
2155       code += get_bits1(&s->gb);
2156    }
2157    sign = code & 1;
2158    code >>= 1;
2159
2160    code = (sign) ? (pred - code) : (pred + code);
2161 #ifdef DEBUG
2162    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2163 #endif
2164    return code;
2165
2166 }
2167
2168 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2169                              int n, int coded)
2170 {
2171     int code, level, i, j, last, run;
2172     RLTable *rl = &rl_inter;
2173     const UINT8 *scan_table;
2174
2175     scan_table = zigzag_direct;
2176     if (s->h263_aic && s->mb_intra) {
2177         rl = &rl_intra_aic;
2178         i = 0;
2179         if (s->ac_pred) {
2180             if (s->h263_aic_dir)
2181                 scan_table = ff_alternate_vertical_scan; /* left */
2182             else
2183                 scan_table = ff_alternate_horizontal_scan; /* top */
2184         }
2185     } else if (s->mb_intra) {
2186         /* DC coef */
2187         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2188             int component, diff;
2189             component = (n <= 3 ? 0 : n - 4 + 1);
2190             level = s->last_dc[component];
2191             if (s->rv10_first_dc_coded[component]) {
2192                 diff = rv_decode_dc(s, n);
2193                 if (diff == 0xffff)
2194                     return -1;
2195                 level += diff;
2196                 level = level & 0xff; /* handle wrap round */
2197                 s->last_dc[component] = level;
2198             } else {
2199                 s->rv10_first_dc_coded[component] = 1;
2200             }
2201         } else {
2202             level = get_bits(&s->gb, 8);
2203             if (level == 255)
2204                 level = 128;
2205         }
2206         block[0] = level;
2207         i = 1;
2208     } else {
2209         i = 0;
2210     }
2211     if (!coded) {
2212         if (s->mb_intra && s->h263_aic)
2213             goto not_coded;
2214         s->block_last_index[n] = i - 1;
2215         return 0;
2216     }
2217
2218     for(;;) {
2219         code = get_vlc(&s->gb, &rl->vlc);
2220         if (code < 0)
2221             return -1;
2222         if (code == rl->n) {
2223             /* escape */
2224             last = get_bits1(&s->gb);
2225             run = get_bits(&s->gb, 6);
2226             level = (INT8)get_bits(&s->gb, 8);
2227             if (s->h263_rv10 && level == -128) {
2228                 /* XXX: should patch encoder too */
2229                 level = get_bits(&s->gb, 12);
2230                 level = (level << 20) >> 20;
2231             }
2232         } else {
2233             run = rl->table_run[code];
2234             level = rl->table_level[code];
2235             last = code >= rl->last;
2236             if (get_bits1(&s->gb))
2237                 level = -level;
2238         }
2239         i += run;
2240         if (i >= 64)
2241             return -1;
2242         j = scan_table[i];
2243         block[j] = level;
2244         if (last)
2245             break;
2246         i++;
2247     }
2248 not_coded:
2249     if (s->mb_intra && s->h263_aic) {
2250         h263_pred_acdc(s, block, n);
2251         i = 63;
2252     }
2253     s->block_last_index[n] = i;
2254     return 0;
2255 }
2256
2257 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2258 {
2259     int level, pred, code;
2260     UINT16 *dc_val;
2261
2262     if (n < 4)
2263         code = get_vlc(&s->gb, &dc_lum);
2264     else
2265         code = get_vlc(&s->gb, &dc_chrom);
2266     if (code < 0)
2267         return -1;
2268     if (code == 0) {
2269         level = 0;
2270     } else {
2271         level = get_bits(&s->gb, code);
2272         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2273             level = - (level ^ ((1 << code) - 1));
2274         if (code > 8)
2275             skip_bits1(&s->gb); /* marker */
2276     }
2277
2278     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2279     level += pred;
2280     if (level < 0)
2281         level = 0;
2282     if (n < 4) {
2283         *dc_val = level * s->y_dc_scale;
2284     } else {
2285         *dc_val = level * s->c_dc_scale;
2286     }
2287     return level;
2288 }
2289
2290 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2291                               int n, int coded)
2292 {
2293     int code, level, i, j, last, run;
2294     int dc_pred_dir;
2295     RLTable *rl;
2296     const UINT8 *scan_table;
2297
2298     if (s->mb_intra) {
2299         /* DC coef */
2300         level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2301         if (level < 0)
2302             return -1;
2303         block[0] = level;
2304         i = 1;
2305         if (!coded)
2306             goto not_coded;
2307         rl = &rl_intra;
2308         if (s->ac_pred) {
2309             if (dc_pred_dir == 0)
2310                 scan_table = ff_alternate_vertical_scan; /* left */
2311             else
2312                 scan_table = ff_alternate_horizontal_scan; /* top */
2313         } else {
2314             scan_table = zigzag_direct;
2315         }
2316     } else {
2317         i = 0;
2318         if (!coded) {
2319             s->block_last_index[n] = i - 1;
2320             return 0;
2321         }
2322         rl = &rl_inter;
2323         scan_table = zigzag_direct;
2324     }
2325
2326     for(;;) {
2327         code = get_vlc(&s->gb, &rl->vlc);
2328         if (code < 0)
2329             return -1;
2330         if (code == rl->n) {
2331             /* escape */
2332             if (get_bits1(&s->gb) != 0) {
2333                 if (get_bits1(&s->gb) != 0) {
2334                     /* third escape */
2335                     last = get_bits1(&s->gb);
2336                     run = get_bits(&s->gb, 6);
2337                     get_bits1(&s->gb); /* marker */
2338                     level = get_bits(&s->gb, 12);
2339                     level = (level << 20) >> 20; /* sign extend */
2340                     skip_bits1(&s->gb); /* marker */
2341                 } else {
2342                     /* second escape */
2343                     code = get_vlc(&s->gb, &rl->vlc);
2344                     if (code < 0 || code >= rl->n)
2345                         return -1;
2346                     run = rl->table_run[code];
2347                     level = rl->table_level[code];
2348                     last = code >= rl->last;
2349                     run += rl->max_run[last][level] + 1;
2350                     if (get_bits1(&s->gb))
2351                         level = -level;
2352                 }
2353             } else {
2354                 /* first escape */
2355                 code = get_vlc(&s->gb, &rl->vlc);
2356                 if (code < 0 || code >= rl->n)
2357                     return -1;
2358                 run = rl->table_run[code];
2359                 level = rl->table_level[code];
2360                 last = code >= rl->last;
2361                 level += rl->max_level[last][run];
2362                 if (get_bits1(&s->gb))
2363                     level = -level;
2364             }
2365         } else {
2366             run = rl->table_run[code];
2367             level = rl->table_level[code];
2368             last = code >= rl->last;
2369             if (get_bits1(&s->gb))
2370                 level = -level;
2371         }
2372         i += run;
2373         if (i >= 64)
2374             return -1;
2375         j = scan_table[i];
2376         block[j] = level;
2377         i++;
2378         if (last)
2379             break;
2380     }
2381  not_coded:
2382     if (s->mb_intra) {
2383         mpeg4_pred_ac(s, block, n, dc_pred_dir);
2384         if (s->ac_pred) {
2385             i = 64; /* XXX: not optimal */
2386         }
2387     }
2388     s->block_last_index[n] = i - 1;
2389     return 0;
2390 }
2391
2392 /* most is hardcoded. should extend to handle all h263 streams */
2393 int h263_decode_picture_header(MpegEncContext *s)
2394 {
2395     int format, width, height;
2396
2397     /* picture start code */
2398     if (get_bits(&s->gb, 22) != 0x20) {
2399         fprintf(stderr, "Bad picture start code\n");
2400         return -1;
2401     }
2402     /* temporal reference */
2403     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
2404
2405     /* PTYPE starts here */
2406     if (get_bits1(&s->gb) != 1) {
2407         /* marker */
2408         fprintf(stderr, "Bad marker\n");
2409         return -1;
2410     }
2411     if (get_bits1(&s->gb) != 0) {
2412         fprintf(stderr, "Bad H263 id\n");
2413         return -1;      /* h263 id */
2414     }
2415     skip_bits1(&s->gb); /* split screen off */
2416     skip_bits1(&s->gb); /* camera  off */
2417     skip_bits1(&s->gb); /* freeze picture release off */
2418
2419     /* Reset GOB number */
2420     s->gob_number = 0;
2421
2422     format = get_bits(&s->gb, 3);
2423     /*
2424         0    forbidden
2425         1    sub-QCIF
2426         10   QCIF
2427         7       extended PTYPE (PLUSPTYPE)
2428     */
2429
2430     if (format != 7 && format != 6) {
2431         s->h263_plus = 0;
2432         /* H.263v1 */
2433         width = h263_format[format][0];
2434         height = h263_format[format][1];
2435         if (!width)
2436             return -1;
2437
2438         s->width = width;
2439         s->height = height;
2440         s->pict_type = I_TYPE + get_bits1(&s->gb);
2441
2442         s->unrestricted_mv = get_bits1(&s->gb);
2443         s->h263_long_vectors = s->unrestricted_mv;
2444
2445         if (get_bits1(&s->gb) != 0) {
2446             fprintf(stderr, "H263 SAC not supported\n");
2447             return -1;  /* SAC: off */
2448         }
2449         if (get_bits1(&s->gb) != 0) {
2450             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2451         }
2452
2453         if (get_bits1(&s->gb) != 0) {
2454             fprintf(stderr, "H263 PB frame not supported\n");
2455             return -1;  /* not PB frame */
2456         }
2457         s->qscale = get_bits(&s->gb, 5);
2458         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
2459     } else {
2460         int ufep;
2461
2462         /* H.263v2 */
2463         s->h263_plus = 1;
2464         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
2465
2466         /* ufep other than 0 and 1 are reserved */
2467         if (ufep == 1) {
2468             /* OPPTYPE */
2469             format = get_bits(&s->gb, 3);
2470             dprintf("ufep=1, format: %d\n", format);
2471             skip_bits(&s->gb,1); /* Custom PCF */
2472             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
2473             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
2474             if (get_bits1(&s->gb) != 0) {
2475                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
2476             }
2477             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
2478                 s->h263_aic = 1;
2479             }
2480
2481             skip_bits(&s->gb, 7);
2482             /* these are the 7 bits: (in order of appearence  */
2483             /* Deblocking Filter */
2484             /* Slice Structured */
2485             /* Reference Picture Selection */
2486             /* Independent Segment Decoding */
2487             /* Alternative Inter VLC */
2488             /* Modified Quantization */
2489             /* Prevent start code emulation */
2490
2491             skip_bits(&s->gb, 3); /* Reserved */
2492         } else if (ufep != 0) {
2493             fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
2494             return -1;
2495         }
2496
2497         /* MPPTYPE */
2498         s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
2499         dprintf("pict_type: %d\n", s->pict_type);
2500         if (s->pict_type != I_TYPE &&
2501             s->pict_type != P_TYPE)
2502             return -1;
2503         skip_bits(&s->gb, 2);
2504         s->no_rounding = get_bits1(&s->gb);
2505         dprintf("RTYPE: %d\n", s->no_rounding);
2506         skip_bits(&s->gb, 4);
2507
2508         /* Get the picture dimensions */
2509         if (ufep) {
2510             if (format == 6) {
2511                 /* Custom Picture Format (CPFMT) */
2512                 s->aspect_ratio_info = get_bits(&s->gb, 4);
2513                 dprintf("aspect: %d\n", s->aspect_ratio_info);
2514                 /* aspect ratios:
2515                 0 - forbidden
2516                 1 - 1:1
2517                 2 - 12:11 (CIF 4:3)
2518                 3 - 10:11 (525-type 4:3)
2519                 4 - 16:11 (CIF 16:9)
2520                 5 - 40:33 (525-type 16:9)
2521                 6-14 - reserved
2522                 */
2523                 width = (get_bits(&s->gb, 9) + 1) * 4;
2524                 skip_bits1(&s->gb);
2525                 height = get_bits(&s->gb, 9) * 4;
2526                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
2527                 if (s->aspect_ratio_info == EXTENDED_PAR) {
2528                     /* aspected dimensions */
2529                     skip_bits(&s->gb, 8); /* width */
2530                     skip_bits(&s->gb, 8); /* height */
2531                 }
2532             } else {
2533                 width = h263_format[format][0];
2534                 height = h263_format[format][1];
2535             }
2536             if ((width == 0) || (height == 0))
2537                 return -1;
2538             s->width = width;
2539             s->height = height;
2540             if (s->umvplus_dec) {
2541                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
2542             }
2543         }
2544
2545         s->qscale = get_bits(&s->gb, 5);
2546     }
2547     /* PEI */
2548     while (get_bits1(&s->gb) != 0) {
2549         skip_bits(&s->gb, 8);
2550     }
2551     s->f_code = 1;
2552     return 0;
2553 }
2554
2555 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
2556 {
2557     int i;
2558     int a= 2<<s->sprite_warping_accuracy;
2559     int rho= 3-s->sprite_warping_accuracy;
2560     int r=16/a;
2561     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
2562     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
2563     int sprite_ref[4][2];
2564     int virtual_ref[2][2];
2565     int w2, h2;
2566     int alpha=0, beta=0;
2567     int w= s->width;
2568     int h= s->height;
2569 //printf("SP %d\n", s->sprite_warping_accuracy);
2570     for(i=0; i<s->num_sprite_warping_points; i++){
2571         int length;
2572         int x=0, y=0;
2573
2574         length= get_vlc(&s->gb, &sprite_trajectory);
2575         if(length){
2576             x= get_bits(&s->gb, length);
2577 //printf("lx %d %d\n", length, x);
2578             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
2579                 x = - (x ^ ((1 << length) - 1));
2580         }
2581         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
2582
2583         length= get_vlc(&s->gb, &sprite_trajectory);
2584         if(length){
2585             y=get_bits(&s->gb, length);
2586 //printf("ly %d %d\n", length, y);
2587             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
2588                 y = - (y ^ ((1 << length) - 1));
2589         }
2590         skip_bits1(&s->gb); /* marker bit */
2591 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
2592 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
2593 //x=y=0;
2594         d[i][0]= x;
2595         d[i][1]= y;
2596     }
2597
2598     while((1<<alpha)<w) alpha++;
2599     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
2600     w2= 1<<alpha;
2601     h2= 1<<beta;
2602
2603 // Note, the 4th point isnt used for GMC
2604     if(s->divx_version==500 && s->divx_build==413){
2605         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
2606         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
2607         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
2608         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
2609         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
2610         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
2611     } else {
2612         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
2613         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
2614         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
2615         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
2616         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
2617         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
2618     }
2619 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
2620     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
2621
2622 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
2623 // perhaps it should be reordered to be more readable ...
2624 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
2625 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
2626     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
2627         + 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);
2628     virtual_ref[0][1]= 16*vop_ref[0][1]
2629         + 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);
2630     virtual_ref[1][0]= 16*vop_ref[0][0]
2631         + 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);
2632     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
2633         + 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);
2634
2635     switch(s->num_sprite_warping_points)
2636     {
2637         case 0:
2638             s->sprite_offset[0][0]= 0;
2639             s->sprite_offset[0][1]= 0;
2640             s->sprite_offset[1][0]= 0;
2641             s->sprite_offset[1][1]= 0;
2642             s->sprite_delta[0][0][0]= a;
2643             s->sprite_delta[0][0][1]= 0;
2644             s->sprite_delta[0][1][0]= 0;
2645             s->sprite_delta[0][1][1]= a;
2646             s->sprite_delta[1][0][0]= a;
2647             s->sprite_delta[1][0][1]= 0;
2648             s->sprite_delta[1][1][0]= 0;
2649             s->sprite_delta[1][1][1]= a;
2650             s->sprite_shift[0][0]= 0;
2651             s->sprite_shift[0][1]= 0;
2652             s->sprite_shift[1][0]= 0;
2653             s->sprite_shift[1][1]= 0;
2654             break;
2655         case 1: //GMC only
2656             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2657             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2658             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2659             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2660             s->sprite_delta[0][0][0]= a;
2661             s->sprite_delta[0][0][1]= 0;
2662             s->sprite_delta[0][1][0]= 0;
2663             s->sprite_delta[0][1][1]= a;
2664             s->sprite_delta[1][0][0]= a;
2665             s->sprite_delta[1][0][1]= 0;
2666             s->sprite_delta[1][1][0]= 0;
2667             s->sprite_delta[1][1][1]= a;
2668             s->sprite_shift[0][0]= 0;
2669             s->sprite_shift[0][1]= 0;
2670             s->sprite_shift[1][0]= 0;
2671             s->sprite_shift[1][1]= 0;
2672             break;
2673         case 2:
2674         case 3: //FIXME
2675             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2676                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2677                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2678             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2679                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2680                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2681             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2682                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2683                                  +2*w2*r*sprite_ref[0][0] - 16*w2);
2684             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
2685                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2686                                  +2*w2*r*sprite_ref[0][1] - 16*w2);
2687             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2688             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2689             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2690             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2691             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2692             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2693             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2694             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2695             s->sprite_shift[0][0]= alpha+rho;
2696             s->sprite_shift[0][1]= alpha+rho;
2697             s->sprite_shift[1][0]= alpha+rho+2;
2698             s->sprite_shift[1][1]= alpha+rho+2;
2699             break;
2700 //        case 3:
2701             break;
2702     }
2703 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2704 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2705 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2706 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2707 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2708 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2709 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2710 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2711     /* try to simplify the situation */
2712     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2713        && s->sprite_delta[0][0][1] == 0
2714        && s->sprite_delta[0][1][0] == 0
2715        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2716        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2717        && s->sprite_delta[1][0][1] == 0
2718        && s->sprite_delta[1][1][0] == 0
2719        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2720     {
2721         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2722         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2723         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2724         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2725         s->sprite_delta[0][0][0]= a;
2726         s->sprite_delta[0][0][1]= 0;
2727         s->sprite_delta[0][1][0]= 0;
2728         s->sprite_delta[0][1][1]= a;
2729         s->sprite_delta[1][0][0]= a;
2730         s->sprite_delta[1][0][1]= 0;
2731         s->sprite_delta[1][1][0]= 0;
2732         s->sprite_delta[1][1][1]= a;
2733         s->sprite_shift[0][0]= 0;
2734         s->sprite_shift[0][1]= 0;
2735         s->sprite_shift[1][0]= 0;
2736         s->sprite_shift[1][1]= 0;
2737         s->real_sprite_warping_points=1;
2738     }
2739     else
2740         s->real_sprite_warping_points= s->num_sprite_warping_points;
2741
2742 //printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
2743 }
2744
2745 /* decode mpeg4 VOP header */
2746 int mpeg4_decode_picture_header(MpegEncContext * s)
2747 {
2748     int time_incr, startcode, state, v;
2749     int time_increment;
2750
2751  redo:
2752     /* search next start code */
2753     align_get_bits(&s->gb);
2754     state = 0xff;
2755     for(;;) {
2756         v = get_bits(&s->gb, 8);
2757         if (state == 0x000001) {
2758             state = ((state << 8) | v) & 0xffffff;
2759             startcode = state;
2760             break;
2761         }
2762         state = ((state << 8) | v) & 0xffffff;
2763         if( get_bits_count(&s->gb) > s->gb.size*8-32){
2764             if(s->gb.size>50){
2765                 printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
2766                 return -1;
2767             }else{
2768                 printf("frame skip\n");
2769                 return FRAME_SKIPED;
2770             }
2771         }
2772     }
2773 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2774     if (startcode == 0x120) { // Video Object Layer
2775         int width, height, vo_ver_id;
2776
2777         /* vol header */
2778         skip_bits(&s->gb, 1); /* random access */
2779         s->vo_type= get_bits(&s->gb, 8);
2780         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2781             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2782             skip_bits(&s->gb, 3); /* vo_priority */
2783         } else {
2784             vo_ver_id = 1;
2785         }
2786 //printf("vo type:%d\n",s->vo_type);
2787         s->aspect_ratio_info= get_bits(&s->gb, 4);
2788         if(s->aspect_ratio_info == EXTENDED_PAR){
2789             skip_bits(&s->gb, 8); //par_width
2790             skip_bits(&s->gb, 8); // par_height
2791         }
2792
2793         if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
2794             int chroma_format= get_bits(&s->gb, 2);
2795             if(chroma_format!=1){
2796                 printf("illegal chroma format\n");
2797             }
2798             s->low_delay= get_bits1(&s->gb);
2799             if(get_bits1(&s->gb)){ /* vbv parameters */
2800                 printf("vbv parameters not supported\n");
2801                 return -1;
2802             }
2803         }else{
2804             s->low_delay=0;
2805         }
2806
2807         s->shape = get_bits(&s->gb, 2); /* vol shape */
2808         if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2809         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2810             printf("Gray shape not supported\n");
2811             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2812         }
2813
2814         skip_bits1(&s->gb);   /* marker */
2815
2816         s->time_increment_resolution = get_bits(&s->gb, 16);
2817         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2818         if (s->time_increment_bits < 1)
2819             s->time_increment_bits = 1;
2820         skip_bits1(&s->gb);   /* marker */
2821
2822         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2823             skip_bits(&s->gb, s->time_increment_bits);
2824         }
2825
2826         if (s->shape != BIN_ONLY_SHAPE) {
2827             if (s->shape == RECT_SHAPE) {
2828                 skip_bits1(&s->gb);   /* marker */
2829                 width = get_bits(&s->gb, 13);
2830                 skip_bits1(&s->gb);   /* marker */
2831                 height = get_bits(&s->gb, 13);
2832                 skip_bits1(&s->gb);   /* marker */
2833                 if(width && height){ /* they should be non zero but who knows ... */
2834                     s->width = width;
2835                     s->height = height;
2836 //                    printf("width/height: %d %d\n", width, height);
2837                 }
2838             }
2839
2840             if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2841             if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2842             if (vo_ver_id == 1) {
2843                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2844             } else {
2845                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2846             }
2847             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2848             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2849                 if(s->vol_sprite_usage==STATIC_SPRITE){
2850                     s->sprite_width = get_bits(&s->gb, 13);
2851                     skip_bits1(&s->gb); /* marker */
2852                     s->sprite_height= get_bits(&s->gb, 13);
2853                     skip_bits1(&s->gb); /* marker */
2854                     s->sprite_left  = get_bits(&s->gb, 13);
2855                     skip_bits1(&s->gb); /* marker */
2856                     s->sprite_top   = get_bits(&s->gb, 13);
2857                     skip_bits1(&s->gb); /* marker */
2858                 }
2859                 s->num_sprite_warping_points= get_bits(&s->gb, 6);
2860                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2861                 s->sprite_brightness_change= get_bits1(&s->gb);
2862                 if(s->vol_sprite_usage==STATIC_SPRITE)
2863                     s->low_latency_sprite= get_bits1(&s->gb);
2864             }
2865             // FIXME sadct disable bit if verid!=1 && shape not rect
2866
2867             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2868                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2869                 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2870                 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
2871             } else {
2872                 s->quant_precision = 5;
2873             }
2874
2875             // FIXME a bunch of grayscale shape things
2876
2877             if(get_bits1(&s->gb)){ /* vol_quant_type */
2878                 int i, j, v;
2879                 /* load default matrixes */
2880                 for(i=0; i<64; i++){
2881                     v= ff_mpeg4_default_intra_matrix[i];
2882                     s->intra_matrix[i]= v;
2883                     s->chroma_intra_matrix[i]= v;
2884
2885                     v= ff_mpeg4_default_non_intra_matrix[i];
2886                     s->inter_matrix[i]= v;
2887                     s->chroma_inter_matrix[i]= v;
2888                 }
2889
2890                 /* load custom intra matrix */
2891                 if(get_bits1(&s->gb)){
2892                     for(i=0; i<64; i++){
2893                         v= get_bits(&s->gb, 8);
2894                         if(v==0) break;
2895
2896                         j= zigzag_direct[i];
2897                         s->intra_matrix[j]= v;
2898                         s->chroma_intra_matrix[j]= v;
2899                     }
2900                 }
2901
2902                 /* load custom non intra matrix */
2903                 if(get_bits1(&s->gb)){
2904                     for(i=0; i<64; i++){
2905                         v= get_bits(&s->gb, 8);
2906                         if(v==0) break;
2907
2908                         j= zigzag_direct[i];
2909                         s->inter_matrix[j]= v;
2910                         s->chroma_inter_matrix[j]= v;
2911                     }
2912
2913                     /* replicate last value */
2914                     for(; i<64; i++){
2915                         j= zigzag_direct[i];
2916                         s->inter_matrix[j]= v;
2917                         s->chroma_inter_matrix[j]= v;
2918                     }
2919                 }
2920
2921                 s->dct_unquantize= s->dct_unquantize_mpeg2;
2922
2923                 // FIXME a bunch of grayscale shape things
2924             }else
2925                 s->dct_unquantize= s->dct_unquantize_h263;
2926
2927             if(vo_ver_id != 1)
2928                  s->quarter_sample= get_bits1(&s->gb);
2929             else s->quarter_sample=0;
2930
2931             if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2932
2933             s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
2934
2935             s->data_partioning= get_bits1(&s->gb);
2936             if(s->data_partioning){
2937                 printf("data partitioning not supported\n");
2938                 skip_bits1(&s->gb); // reversible vlc
2939             }
2940
2941             if(vo_ver_id != 1) {
2942                 s->new_pred= get_bits1(&s->gb);
2943                 if(s->new_pred){
2944                     printf("new pred not supported\n");
2945                     skip_bits(&s->gb, 2); /* requested upstream message type */
2946                     skip_bits1(&s->gb); /* newpred segment type */
2947                 }
2948                 s->reduced_res_vop= get_bits1(&s->gb);
2949                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2950             }
2951             else{
2952                 s->new_pred=0;
2953                 s->reduced_res_vop= 0;
2954             }
2955
2956             s->scalability= get_bits1(&s->gb);
2957             if (s->scalability) {
2958                 printf("scalability not supported\n");
2959             }
2960         }
2961 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2962         goto redo;
2963     } else if (startcode == 0x1b2) { //userdata
2964         char buf[256];
2965         int i;
2966         int e;
2967         int ver, build;
2968
2969 //printf("user Data %X\n", show_bits(&s->gb, 32));
2970         buf[0]= show_bits(&s->gb, 8);
2971         for(i=1; i<256; i++){
2972             buf[i]= show_bits(&s->gb, 16)&0xFF;
2973             if(buf[i]==0) break;
2974             skip_bits(&s->gb, 8);
2975         }
2976         buf[255]=0;
2977         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2978         if(e!=2)
2979             e=sscanf(buf, "DivX%db%d", &ver, &build);
2980         if(e==2){
2981             s->divx_version= ver;
2982             s->divx_build= build;
2983             if(s->picture_number==0){
2984                 printf("This file was encoded with DivX%d Build%d\n", ver, build);
2985                 if(ver==500 && build==413){
2986                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2987 #if 0
2988                 }else{
2989                     printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2990                            "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2991 #endif
2992                 }
2993             }
2994         }
2995 //printf("User Data: %s\n", buf);
2996         goto redo;
2997     } else if (startcode != 0x1b6) { //VOP
2998         goto redo;
2999     }
3000
3001     s->pict_type = get_bits(&s->gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
3002     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
3003         printf("low_delay flag set, but shouldnt, clearing it\n");
3004         s->low_delay=0;
3005     }
3006 // printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample);
3007     time_incr=0;
3008     while (get_bits1(&s->gb) != 0)
3009         time_incr++;
3010
3011     check_marker(&s->gb, "before time_increment");
3012     time_increment= get_bits(&s->gb, s->time_increment_bits);
3013 //printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
3014     if(s->pict_type!=B_TYPE){
3015         s->last_time_base= s->time_base;
3016         s->time_base+= time_incr;
3017         s->time= s->time_base*s->time_increment_resolution + time_increment;
3018         s->pp_time= s->time - s->last_non_b_time;
3019         s->last_non_b_time= s->time;
3020     }else{
3021         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
3022         s->bp_time= s->last_non_b_time - s->time;
3023         if(s->pp_time <=s->bp_time){
3024 //            printf("messed up order, seeking?, skiping current b frame\n");
3025             return FRAME_SKIPED;
3026         }
3027     }
3028
3029     if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
3030         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
3031         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
3032             if(get_bits1(&s->gb)) break;
3033         }
3034         printf("my guess is %d bits ;)\n",s->time_increment_bits);
3035     }
3036     /* vop coded */
3037     if (get_bits1(&s->gb) != 1)
3038         goto redo;
3039 //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
3040 //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);
3041     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
3042                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
3043         /* rounding type for motion estimation */
3044         s->no_rounding = get_bits1(&s->gb);
3045     } else {
3046         s->no_rounding = 0;
3047     }
3048 //FIXME reduced res stuff
3049
3050      if (s->shape != RECT_SHAPE) {
3051          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
3052              int width, height, hor_spat_ref, ver_spat_ref;
3053
3054              width = get_bits(&s->gb, 13);
3055              skip_bits1(&s->gb);   /* marker */
3056              height = get_bits(&s->gb, 13);
3057              skip_bits1(&s->gb);   /* marker */
3058              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
3059              skip_bits1(&s->gb);   /* marker */
3060              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
3061          }
3062          skip_bits1(&s->gb); /* change_CR_disable */
3063
3064          if (get_bits1(&s->gb) != 0) {
3065              skip_bits(&s->gb, 8); /* constant_alpha_value */
3066          }
3067      }
3068 //FIXME complexity estimation stuff
3069
3070      if (s->shape != BIN_ONLY_SHAPE) {
3071          int t;
3072          t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
3073 //printf("threshold %d\n", t);
3074          //FIXME interlaced specific bits
3075      }
3076
3077      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
3078          if(s->num_sprite_warping_points){
3079              mpeg4_decode_sprite_trajectory(s);
3080          }
3081          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
3082          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
3083      }
3084
3085      if (s->shape != BIN_ONLY_SHAPE) {
3086          /* note: we do not use quant_precision to avoid problem if no
3087             MPEG4 vol header as it is found on some old opendivx
3088             movies */
3089          s->qscale = get_bits(&s->gb, 5);
3090          if(s->qscale==0){
3091              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
3092              return -1; // makes no sense to continue, as there is nothing left from the image then
3093          }
3094
3095          if (s->pict_type != I_TYPE) {
3096              s->f_code = get_bits(&s->gb, 3);   /* fcode_for */
3097              if(s->f_code==0){
3098                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
3099                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
3100              }
3101          }
3102          if (s->pict_type == B_TYPE) {
3103              s->b_code = get_bits(&s->gb, 3);
3104 //printf("b-code %d\n", s->b_code);
3105          }
3106 //printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
3107          if(!s->scalability){
3108              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
3109                  skip_bits1(&s->gb); // vop shape coding type
3110              }
3111          }
3112      }
3113      /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
3114      // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
3115      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
3116          printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
3117          s->low_delay=1;
3118      }
3119
3120      s->picture_number++; // better than pic number==0 allways ;)
3121 //printf("done\n");
3122
3123      return 0;
3124 }
3125
3126 /* don't understand why they choose a different header ! */
3127 int intel_h263_decode_picture_header(MpegEncContext *s)
3128 {
3129     int format;
3130
3131     /* picture header */
3132     if (get_bits(&s->gb, 22) != 0x20) {
3133         fprintf(stderr, "Bad picture start code\n");
3134         return -1;
3135     }
3136     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3137
3138     if (get_bits1(&s->gb) != 1) {
3139         fprintf(stderr, "Bad marker\n");
3140         return -1;      /* marker */
3141     }
3142     if (get_bits1(&s->gb) != 0) {
3143         fprintf(stderr, "Bad H263 id\n");
3144         return -1;      /* h263 id */
3145     }
3146     skip_bits1(&s->gb); /* split screen off */
3147     skip_bits1(&s->gb); /* camera  off */
3148     skip_bits1(&s->gb); /* freeze picture release off */
3149
3150     format = get_bits(&s->gb, 3);
3151     if (format != 7) {
3152         fprintf(stderr, "Intel H263 free format not supported\n");
3153         return -1;
3154     }
3155     s->h263_plus = 0;
3156
3157     s->pict_type = I_TYPE + get_bits1(&s->gb);
3158
3159     s->unrestricted_mv = get_bits1(&s->gb);
3160     s->h263_long_vectors = s->unrestricted_mv;
3161
3162     if (get_bits1(&s->gb) != 0) {
3163         fprintf(stderr, "SAC not supported\n");
3164         return -1;      /* SAC: off */
3165     }
3166     if (get_bits1(&s->gb) != 0) {
3167         fprintf(stderr, "Advanced Prediction Mode not supported\n");
3168         return -1;      /* advanced prediction mode: off */
3169     }
3170     if (get_bits1(&s->gb) != 0) {
3171         fprintf(stderr, "PB frame mode no supported\n");
3172         return -1;      /* PB frame mode */
3173     }
3174
3175     /* skip unknown header garbage */
3176     skip_bits(&s->gb, 41);
3177
3178     s->qscale = get_bits(&s->gb, 5);
3179     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
3180
3181     /* PEI */
3182     while (get_bits1(&s->gb) != 0) {
3183         skip_bits(&s->gb, 8);
3184     }
3185     s->f_code = 1;
3186     return 0;
3187 }
3188