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

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