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

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