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 /**
  27  * @file h263.c
  28  * h263/mpeg4 codec.
  29  */
  30
  31 //#define DEBUG
  32 #include <limits.h>
  33
  34 #include "common.h"
  35 #include "dsputil.h"
  36 #include "avcodec.h"
  37 #include "mpegvideo.h"
  38 #include "h263data.h"
  39 #include "mpeg4data.h"
  40
  41 //#undef NDEBUG
  42 //#include <assert.h>
  43
  44 #define INTRA_MCBPC_VLC_BITS 6
  45 #define INTER_MCBPC_VLC_BITS 7
  46 #define CBPY_VLC_BITS 6
  47 #define MV_VLC_BITS 9
  48 #define DC_VLC_BITS 9
  49 #define SPRITE_TRAJ_VLC_BITS 6
  50 #define MB_TYPE_B_VLC_BITS 4
  51 #define TEX_VLC_BITS 9
  52
  53 #ifdef CONFIG_ENCODERS
  54 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  55                               int n);
  56 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
  57 static void h263p_encode_umotion(MpegEncContext * s, int val);
  58 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  59                                int n, int dc, uint8_t *scan_table,
  60                                PutBitContext *dc_pb, PutBitContext *ac_pb);
  61 #endif
  62
  63 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
  64 static int h263p_decode_umotion(MpegEncContext * s, int pred);
  65 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  66                              int n, int coded);
  67 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
  68 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  69                               int n, int coded, int intra, int rvlc);
  70 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
  71 #ifdef CONFIG_ENCODERS
  72 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
  73 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
  74 #endif //CONFIG_ENCODERS
  75 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
  76 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
  77
  78 #ifdef CONFIG_ENCODERS
  79 static uint8_t uni_DCtab_lum_len[512];
  80 static uint8_t uni_DCtab_chrom_len[512];
  81 static uint16_t uni_DCtab_lum_bits[512];
  82 static uint16_t uni_DCtab_chrom_bits[512];
  83
  84 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
  85 static uint8_t fcode_tab[MAX_MV*2+1];
  86 static uint8_t umv_fcode_tab[MAX_MV*2+1];
  87
  88 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
  89 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
  90 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
  91 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
  92 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
  93 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
  94 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
  95
  96 /* mpeg4
  97 inter
  98 max level: 24/6
  99 max run: 53/63
 100
 101 intra
 102 max level: 53/16
 103 max run: 29/41
 104 */
 105 #endif
 106
 107 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit
 108 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
 109 #else
 110 #define IS_3IV1 0
 111 #endif
 112
 113 int h263_get_picture_format(int width, int height)
 114 {
 115     int format;
 116
 117     if (width == 128 && height == 96)
 118         format = 1;
 119     else if (width == 176 && height == 144)
 120         format = 2;
 121     else if (width == 352 && height == 288)
 122         format = 3;
 123     else if (width == 704 && height == 576)
 124         format = 4;
 125     else if (width == 1408 && height == 1152)
 126         format = 5;
 127     else
 128         format = 7;
 129     return format;
 130 }
 131
 132 #ifdef CONFIG_ENCODERS
 133
 134 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
 135     int i;
 136
 137     if(aspect.num==0) aspect= (AVRational){1,1};
 138
 139     for(i=1; i<6; i++){
 140         if(av_cmp_q(pixel_aspect[i], aspect) == 0){
 141             s->aspect_ratio_info=i;
 142             return;
 143         }
 144     }
 145
 146     s->aspect_ratio_info= FF_ASPECT_EXTENDED;
 147 }
 148
 149 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
 150 {
 151       int format;
 152
 153       align_put_bits(&s->pb);
 154
 155       put_bits(&s->pb, 17, 1);
 156       put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
 157       put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
 158                            s->avctx->frame_rate) & 0xff); /* TemporalReference */
 159       if (s->width == 352 && s->height == 288)
 160         format = 2;
 161       else if (s->width == 176 && s->height == 144)
 162         format = 3;
 163       else if (s->width == 128 && s->height == 96)
 164         format = 4;
 165       else if (s->width == 320 && s->height == 240)
 166         format = 5;
 167       else if (s->width == 160 && s->height == 120)
 168         format = 6;
 169       else if (s->width <= 255 && s->height <= 255)
 170         format = 0; /* use 1 byte width & height */
 171       else
 172         format = 1; /* use 2 bytes width & height */
 173       put_bits(&s->pb, 3, format); /* PictureSize */
 174       if (format == 0) {
 175         put_bits(&s->pb, 8, s->width);
 176         put_bits(&s->pb, 8, s->height);
 177       } else if (format == 1) {
 178         put_bits(&s->pb, 16, s->width);
 179         put_bits(&s->pb, 16, s->height);
 180       }
 181       put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
 182       put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
 183       put_bits(&s->pb, 5, s->qscale); /* Quantizer */
 184       put_bits(&s->pb, 1, 0); /* ExtraInformation */
 185
 186       if(s->h263_aic){
 187         s->y_dc_scale_table=
 188           s->c_dc_scale_table= ff_aic_dc_scale_table;
 189       }else{
 190         s->y_dc_scale_table=
 191           s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 192       }
 193 }
 194
 195 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
 196 {
 197     int format;
 198
 199     align_put_bits(&s->pb);
 200
 201     /* Update the pointer to last GOB */
 202     s->ptr_lastgob = pbBufPtr(&s->pb);
 203     s->gob_number = 0;
 204
 205     put_bits(&s->pb, 22, 0x20); /* PSC */
 206     put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
 207                          s->avctx->frame_rate) & 0xff);
 208
 209     put_bits(&s->pb, 1, 1);     /* marker */
 210     put_bits(&s->pb, 1, 0);     /* h263 id */
 211     put_bits(&s->pb, 1, 0);     /* split screen off */
 212     put_bits(&s->pb, 1, 0);     /* camera  off */
 213     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
 214
 215     format = h263_get_picture_format(s->width, s->height);
 216     if (!s->h263_plus) {
 217         /* H.263v1 */
 218         put_bits(&s->pb, 3, format);
 219         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
 220         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
 221         of H.263v1 UMV implies to check the predicted MV after
 222         calculation of the current MB to see if we're on the limits */
 223         put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
 224         put_bits(&s->pb, 1, 0); /* SAC: off */
 225         put_bits(&s->pb, 1, s->obmc);   /* advanced prediction mode */
 226         put_bits(&s->pb, 1, 0); /* not PB frame */
 227         put_bits(&s->pb, 5, s->qscale);
 228         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 229     } else {
 230         /* H.263v2 */
 231         /* H.263 Plus PTYPE */
 232         put_bits(&s->pb, 3, 7);
 233         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
 234         if (format == 7)
 235             put_bits(&s->pb,3,6); /* Custom Source Format */
 236         else
 237             put_bits(&s->pb, 3, format);
 238
 239         put_bits(&s->pb,1,0); /* Custom PCF: off */
 240         s->umvplus = s->unrestricted_mv;
 241         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
 242         put_bits(&s->pb,1,0); /* SAC: off */
 243         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
 244         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 245         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
 246         put_bits(&s->pb,1,0); /* Slice Structured: off */
 247         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 248         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 249         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
 250         put_bits(&s->pb,1,0); /* Modified Quantization: off */
 251         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 252         put_bits(&s->pb,3,0); /* Reserved */
 253
 254         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
 255
 256         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 257         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 258         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 259         put_bits(&s->pb,2,0); /* Reserved */
 260         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 261
 262         /* This should be here if PLUSPTYPE */
 263         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 264
 265                 if (format == 7) {
 266             /* Custom Picture Format (CPFMT) */
 267             aspect_to_info(s, s->avctx->sample_aspect_ratio);
 268
 269             put_bits(&s->pb,4,s->aspect_ratio_info);
 270             put_bits(&s->pb,9,(s->width >> 2) - 1);
 271             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 272             put_bits(&s->pb,9,(s->height >> 2));
 273             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
 274                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
 275                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
 276             }
 277         }
 278
 279         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 280         if (s->umvplus)
 281 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 282             put_bits(&s->pb,2,1); /* unlimited */
 283
 284         put_bits(&s->pb, 5, s->qscale);
 285     }
 286
 287     put_bits(&s->pb, 1, 0);     /* no PEI */
 288
 289     if(s->h263_aic){
 290          s->y_dc_scale_table=
 291          s->c_dc_scale_table= ff_aic_dc_scale_table;
 292     }else{
 293         s->y_dc_scale_table=
 294         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 295     }
 296 }
 297
 298 /**
 299  * Encodes a group of blocks header.
 300  */
 301 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
 302 {
 303            align_put_bits(&s->pb);
 304            flush_put_bits(&s->pb);
 305            /* Call the RTP callback to send the last GOB */
 306            if (s->rtp_callback) {
 307                int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 308                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
 309            }
 310            put_bits(&s->pb, 17, 1); /* GBSC */
 311            s->gob_number = mb_line / s->gob_index;
 312            put_bits(&s->pb, 5, s->gob_number); /* GN */
 313            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 314            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 315            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
 316     return 0;
 317 }
 318
 319 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
 320     int last=0;
 321     int j;
 322     int rate=0;
 323
 324     for(j=1; j<=block_last_index; j++){
 325         const int index= scantable[j];
 326         int level= block[index];
 327         if(level){
 328             level+= 64;
 329             if((level&(~127)) == 0){
 330                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
 331                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
 332             }else
 333                 rate += s->ac_esc_length;
 334             level-= 64;
 335
 336             last= j;
 337         }
 338     }
 339
 340     return rate;
 341 }
 342
 343 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
 344 {
 345     int score= 0;
 346     int i, n;
 347     int8_t * const qscale_table= s->current_picture.qscale_table;
 348
 349     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
 350
 351     for(n=0; n<6; n++){
 352         int16_t *ac_val, *ac_val1;
 353
 354         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
 355
 356         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 357         ac_val1= ac_val;
 358         if(dir[n]){
 359             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
 360             /* top prediction */
 361             ac_val-= s->block_wrap[n]*16;
 362             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
 363                 /* same qscale */
 364                 for(i=1; i<8; i++){
 365                     const int level= block[n][s->dsp.idct_permutation[i   ]];
 366                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
 367                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
 368                     ac_val1[i+8]= level;
 369                 }
 370             }else{
 371                 /* different qscale, we must rescale */
 372                 for(i=1; i<8; i++){
 373                     const int level= block[n][s->dsp.idct_permutation[i   ]];
 374                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
 375                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
 376                     ac_val1[i+8]= level;
 377                 }
 378             }
 379             st[n]= s->intra_h_scantable.permutated;
 380         }else{
 381             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
 382             /* left prediction */
 383             ac_val-= 16;
 384             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
 385                 /* same qscale */
 386                 for(i=1; i<8; i++){
 387                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
 388                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
 389                     ac_val1[i  ]= level;
 390                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
 391                 }
 392             }else{
 393                 /* different qscale, we must rescale */
 394                 for(i=1; i<8; i++){
 395                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
 396                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
 397                     ac_val1[i  ]= level;
 398                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
 399                 }
 400             }
 401             st[n]= s->intra_v_scantable.permutated;
 402         }
 403
 404         for(i=63; i>0; i--) //FIXME optimize
 405             if(block[n][ st[n][i] ]) break;
 406         s->block_last_index[n]= i;
 407
 408         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
 409     }
 410
 411     return score < 0;
 412 }
 413
 414 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
 415 {
 416     int i, n;
 417     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
 418
 419     for(n=0; n<6; n++){
 420         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 421
 422         st[n]= s->intra_scantable.permutated;
 423         if(dir[n]){
 424             /* top prediction */
 425             for(i=1; i<8; i++){
 426                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
 427             }
 428         }else{
 429             /* left prediction */
 430             for(i=1; i<8; i++){
 431                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
 432             }
 433         }
 434     }
 435 }
 436
 437 /**
 438  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 439  */
 440 void ff_clean_h263_qscales(MpegEncContext *s){
 441     int i;
 442     int8_t * const qscale_table= s->current_picture.qscale_table;
 443
 444     for(i=1; i<s->mb_num; i++){
 445         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
 446             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
 447     }
 448     for(i=s->mb_num-2; i>=0; i--){
 449         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
 450             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
 451     }
 452 }
 453
 454 /**
 455  * modify mb_type & qscale so that encoding is acually possible in mpeg4
 456  */
 457 void ff_clean_mpeg4_qscales(MpegEncContext *s){
 458     int i;
 459     int8_t * const qscale_table= s->current_picture.qscale_table;
 460
 461     ff_clean_h263_qscales(s);
 462
 463     for(i=1; i<s->mb_num; i++){
 464         int mb_xy= s->mb_index2xy[i];
 465
 466         if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
 467             s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
 468             s->mb_type[mb_xy]|= MB_TYPE_INTER;
 469         }
 470     }
 471
 472     if(s->pict_type== B_TYPE){
 473         int odd=0;
 474         /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
 475            for the actual adaptive quantization */
 476
 477         for(i=0; i<s->mb_num; i++){
 478             int mb_xy= s->mb_index2xy[i];
 479             odd += qscale_table[mb_xy]&1;
 480         }
 481
 482         if(2*odd > s->mb_num) odd=1;
 483         else                  odd=0;
 484
 485         for(i=0; i<s->mb_num; i++){
 486             int mb_xy= s->mb_index2xy[i];
 487             if((qscale_table[mb_xy]&1) != odd)
 488                 qscale_table[mb_xy]++;
 489             if(qscale_table[mb_xy] > 31)
 490                 qscale_table[mb_xy]= 31;
 491         }
 492
 493         for(i=1; i<s->mb_num; i++){
 494             int mb_xy= s->mb_index2xy[i];
 495             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
 496                 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
 497                 s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
 498             }
 499         }
 500     }
 501 }
 502
 503 #endif //CONFIG_ENCODERS
 504 /**
 505  *
 506  * @return the mb_type
 507  */
 508 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
 509     const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
 510     const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
 511     int xy= s->block_index[0];
 512     uint16_t time_pp= s->pp_time;
 513     uint16_t time_pb= s->pb_time;
 514     int i;
 515
 516     //FIXME avoid divides
 517
 518     if(IS_8X8(colocated_mb_type)){
 519         s->mv_type = MV_TYPE_8X8;
 520         for(i=0; i<4; i++){
 521             xy= s->block_index[i];
 522             s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
 523             s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
 524             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
 525                                 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
 526             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
 527                                 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
 528         }
 529         return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
 530     } else if(IS_INTERLACED(colocated_mb_type)){
 531         s->mv_type = MV_TYPE_FIELD;
 532         for(i=0; i<2; i++){
 533             if(s->top_field_first){
 534                 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
 535                 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
 536             }else{
 537                 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
 538                 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
 539             }
 540             s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
 541             s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
 542             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
 543                                 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
 544             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
 545                                 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
 546         }
 547         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
 548     }else{
 549         s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
 550         s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
 551         s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
 552                             : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
 553         s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
 554                             : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
 555         if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
 556             s->mv_type= MV_TYPE_16X16;
 557         else
 558             s->mv_type= MV_TYPE_8X8;
 559         return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
 560     }
 561 }
 562
 563 void ff_h263_update_motion_val(MpegEncContext * s){
 564     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
 565                //FIXME a lot of thet is only needed for !low_delay
 566     const int wrap = s->block_wrap[0];
 567     const int xy = s->block_index[0];
 568
 569     s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
 570
 571     if(s->mv_type != MV_TYPE_8X8){
 572         int motion_x, motion_y;
 573         if (s->mb_intra) {
 574             motion_x = 0;
 575             motion_y = 0;
 576         } else if (s->mv_type == MV_TYPE_16X16) {
 577             motion_x = s->mv[0][0][0];
 578             motion_y = s->mv[0][0][1];
 579         } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
 580             int i;
 581             motion_x = s->mv[0][0][0] + s->mv[0][1][0];
 582             motion_y = s->mv[0][0][1] + s->mv[0][1][1];
 583             motion_x = (motion_x>>1) | (motion_x&1);
 584             for(i=0; i<2; i++){
 585                 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
 586                 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
 587                 s->field_select_table[mb_xy][i]= s->field_select[0][i];
 588             }
 589         }
 590
 591         /* no update if 8X8 because it has been done during parsing */
 592         s->motion_val[xy][0] = motion_x;
 593         s->motion_val[xy][1] = motion_y;
 594         s->motion_val[xy + 1][0] = motion_x;
 595         s->motion_val[xy + 1][1] = motion_y;
 596         s->motion_val[xy + wrap][0] = motion_x;
 597         s->motion_val[xy + wrap][1] = motion_y;
 598         s->motion_val[xy + 1 + wrap][0] = motion_x;
 599         s->motion_val[xy + 1 + wrap][1] = motion_y;
 600     }
 601
 602     if(s->encoding){ //FIXME encoding MUST be cleaned up
 603         if (s->mv_type == MV_TYPE_8X8)
 604             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
 605         else if(s->mb_intra)
 606             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
 607         else
 608             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
 609     }
 610 }
 611
 612 #ifdef CONFIG_ENCODERS
 613
 614 static inline int get_p_cbp(MpegEncContext * s,
 615                       DCTELEM block[6][64],
 616                       int motion_x, int motion_y){
 617     int cbp, i;
 618
 619     if(s->flags & CODEC_FLAG_CBP_RD){
 620         int best_cbpy_score= INT_MAX;
 621         int best_cbpc_score= INT_MAX;
 622         int cbpc = (-1), cbpy= (-1);
 623         const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
 624         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
 625
 626         for(i=0; i<4; i++){
 627             int score= inter_MCBPC_bits[i + offset] * lambda;
 628             if(i&1) score += s->coded_score[5];
 629             if(i&2) score += s->coded_score[4];
 630
 631             if(score < best_cbpc_score){
 632                 best_cbpc_score= score;
 633                 cbpc= i;
 634             }
 635         }
 636
 637         for(i=0; i<16; i++){
 638             int score= cbpy_tab[i ^ 0xF][1] * lambda;
 639             if(i&1) score += s->coded_score[3];
 640             if(i&2) score += s->coded_score[2];
 641             if(i&4) score += s->coded_score[1];
 642             if(i&8) score += s->coded_score[0];
 643
 644             if(score < best_cbpy_score){
 645                 best_cbpy_score= score;
 646                 cbpy= i;
 647             }
 648         }
 649         cbp= cbpc + 4*cbpy;
 650         if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
 651             if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
 652                 cbp= 0;
 653         }
 654
 655         for (i = 0; i < 6; i++) {
 656             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
 657                 s->block_last_index[i]= -1;
 658                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
 659             }
 660         }
 661     }else{
 662         cbp= 0;
 663         for (i = 0; i < 6; i++) {
 664             if (s->block_last_index[i] >= 0)
 665                 cbp |= 1 << (5 - i);
 666         }
 667     }
 668     return cbp;
 669 }
 670
 671 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
 672                             int motion_x, int motion_y, int mb_type){
 673     int cbp=0, i;
 674
 675     if(s->flags & CODEC_FLAG_CBP_RD){
 676         int score=0;
 677         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
 678
 679         for(i=0; i<6; i++){
 680             if(s->coded_score[i] < 0){
 681                 score += s->coded_score[i];
 682                 cbp |= 1 << (5 - i);
 683             }
 684         }
 685
 686         if(cbp){
 687             int zero_score= -6;
 688             if ((motion_x | motion_y | s->dquant | mb_type) == 0){
 689                 zero_score-= 4; //2*MV + mb_type + cbp bit
 690             }
 691
 692             zero_score*= lambda;
 693             if(zero_score <= score){
 694                 cbp=0;
 695             }
 696         }
 697
 698         for (i = 0; i < 6; i++) {
 699             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
 700                 s->block_last_index[i]= -1;
 701                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
 702             }
 703         }
 704     }else{
 705         for (i = 0; i < 6; i++) {
 706             if (s->block_last_index[i] >= 0)
 707                 cbp |= 1 << (5 - i);
 708         }
 709     }
 710     return cbp;
 711 }
 712
 713 void mpeg4_encode_mb(MpegEncContext * s,
 714                     DCTELEM block[6][64],
 715                     int motion_x, int motion_y)
 716 {
 717     int cbpc, cbpy, pred_x, pred_y;
 718     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
 719     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
 720     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
 721     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
 722     const int dquant_code[5]= {1,0,9,2,3};
 723
 724     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 725     if (!s->mb_intra) {
 726         /* compute cbp */
 727         int i, cbp;
 728
 729         if(s->pict_type==B_TYPE){
 730             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
 731             int mb_type=  mb_type_table[s->mv_dir];
 732
 733             if(s->mb_x==0){
 734                 s->last_mv[0][0][0]=
 735                 s->last_mv[0][0][1]=
 736                 s->last_mv[1][0][0]=
 737                 s->last_mv[1][0][1]= 0;
 738             }
 739
 740             assert(s->dquant>=-2 && s->dquant<=2);
 741             assert((s->dquant&1)==0);
 742             assert(mb_type>=0);
 743
 744             /* nothing to do if this MB was skiped in the next P Frame */
 745             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
 746                 s->skip_count++;
 747                 s->mv[0][0][0]=
 748                 s->mv[0][0][1]=
 749                 s->mv[1][0][0]=
 750                 s->mv[1][0][1]= 0;
 751                 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
 752                 s->qscale -= s->dquant;
 753 //                s->mb_skiped=1;
 754
 755                 return;
 756             }
 757
 758             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
 759
 760             if ((cbp | motion_x | motion_y | mb_type) ==0) {
 761                 /* direct MB with MV={0,0} */
 762                 assert(s->dquant==0);
 763
 764                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
 765
 766                 if(interleaved_stats){
 767                     s->misc_bits++;
 768                     s->last_bits++;
 769                 }
 770                 s->skip_count++;
 771                 return;
 772             }
 773
 774             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
 775             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
 776             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
 777             if(cbp) put_bits(&s->pb, 6, cbp);
 778
 779             if(cbp && mb_type){
 780                 if(s->dquant)
 781                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
 782                 else
 783                     put_bits(&s->pb, 1, 0);
 784             }else
 785                 s->qscale -= s->dquant;
 786
 787             if(!s->progressive_sequence){
 788                 if(cbp)
 789                     put_bits(&s->pb, 1, s->interlaced_dct);
 790                 if(mb_type) // not diect mode
 791                     put_bits(&s->pb, 1, 0); // no interlaced ME yet
 792             }
 793
 794             if(interleaved_stats){
 795                 s->misc_bits+= get_bits_diff(s);
 796             }
 797
 798             switch(mb_type)
 799             {
 800             case 0: /* direct */
 801                 h263_encode_motion(s, motion_x, 1);
 802                 h263_encode_motion(s, motion_y, 1);
 803                 s->b_count++;
 804                 s->f_count++;
 805                 break;
 806             case 1: /* bidir */
 807                 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
 808                 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
 809                 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
 810                 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
 811                 s->last_mv[0][0][0]= s->mv[0][0][0];
 812                 s->last_mv[0][0][1]= s->mv[0][0][1];
 813                 s->last_mv[1][0][0]= s->mv[1][0][0];
 814                 s->last_mv[1][0][1]= s->mv[1][0][1];
 815                 s->b_count++;
 816                 s->f_count++;
 817                 break;
 818             case 2: /* backward */
 819                 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
 820                 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
 821                 s->last_mv[1][0][0]= motion_x;
 822                 s->last_mv[1][0][1]= motion_y;
 823                 s->b_count++;
 824                 break;
 825             case 3: /* forward */
 826                 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
 827                 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
 828                 s->last_mv[0][0][0]= motion_x;
 829                 s->last_mv[0][0][1]= motion_y;
 830                 s->f_count++;
 831                 break;
 832             default:
 833                 av_log(s->avctx, AV_LOG_ERROR, "unknown mb type\n");
 834                 return;
 835             }
 836
 837             if(interleaved_stats){
 838                 s->mv_bits+= get_bits_diff(s);
 839             }
 840
 841             /* encode each block */
 842             for (i = 0; i < 6; i++) {
 843                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
 844             }
 845
 846             if(interleaved_stats){
 847                 s->p_tex_bits+= get_bits_diff(s);
 848             }
 849         }else{ /* s->pict_type==B_TYPE */
 850             cbp= get_p_cbp(s, block, motion_x, motion_y);
 851
 852             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
 853                 /* check if the B frames can skip it too, as we must skip it if we skip here
 854                    why didnt they just compress the skip-mb bits instead of reusing them ?! */
 855                 if(s->max_b_frames>0){
 856                     int i;
 857                     int x,y, offset;
 858                     uint8_t *p_pic;
 859
 860                     x= s->mb_x*16;
 861                     y= s->mb_y*16;
 862                     if(x+16 > s->width)  x= s->width-16;
 863                     if(y+16 > s->height) y= s->height-16;
 864
 865                     offset= x + y*s->linesize;
 866                     p_pic= s->new_picture.data[0] + offset;
 867
 868                     s->mb_skiped=1;
 869                     for(i=0; i<s->max_b_frames; i++){
 870                         uint8_t *b_pic;
 871                         int diff;
 872                         Picture *pic= s->reordered_input_picture[i+1];
 873
 874                         if(pic==NULL || pic->pict_type!=B_TYPE) break;
 875
 876                         b_pic= pic->data[0] + offset + 16; //FIXME +16
 877                         diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
 878                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
 879                             s->mb_skiped=0;
 880                             break;
 881                         }
 882                     }
 883                 }else
 884                     s->mb_skiped=1;
 885
 886                 if(s->mb_skiped==1){
 887                     /* skip macroblock */
 888                     put_bits(&s->pb, 1, 1);
 889
 890                     if(interleaved_stats){
 891                         s->misc_bits++;
 892                         s->last_bits++;
 893                     }
 894                     s->skip_count++;
 895
 896                     return;
 897                 }
 898             }
 899
 900             put_bits(&s->pb, 1, 0);     /* mb coded */
 901             cbpc = cbp & 3;
 902             cbpy = cbp >> 2;
 903             cbpy ^= 0xf;
 904             if(s->mv_type==MV_TYPE_16X16){
 905                 if(s->dquant) cbpc+= 8;
 906                 put_bits(&s->pb,
 907                         inter_MCBPC_bits[cbpc],
 908                         inter_MCBPC_code[cbpc]);
 909
 910                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 911                 if(s->dquant)
 912                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
 913
 914                 if(!s->progressive_sequence){
 915                     if(cbp)
 916                         put_bits(pb2, 1, s->interlaced_dct);
 917                     put_bits(pb2, 1, 0); // no interlaced ME yet
 918                 }
 919
 920                 if(interleaved_stats){
 921                     s->misc_bits+= get_bits_diff(s);
 922                 }
 923
 924                 /* motion vectors: 16x16 mode */
 925                 h263_pred_motion(s, 0, &pred_x, &pred_y);
 926
 927                 h263_encode_motion(s, motion_x - pred_x, s->f_code);
 928                 h263_encode_motion(s, motion_y - pred_y, s->f_code);
 929             }else{
 930                 put_bits(&s->pb,
 931                         inter_MCBPC_bits[cbpc+16],
 932                         inter_MCBPC_code[cbpc+16]);
 933                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 934
 935                 if(!s->progressive_sequence){
 936                     if(cbp)
 937                         put_bits(pb2, 1, s->interlaced_dct);
 938                 }
 939
 940                 if(interleaved_stats){
 941                     s->misc_bits+= get_bits_diff(s);
 942                 }
 943
 944                 for(i=0; i<4; i++){
 945                     /* motion vectors: 8x8 mode*/
 946                     h263_pred_motion(s, i, &pred_x, &pred_y);
 947
 948                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
 949                     h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
 950                 }
 951             }
 952
 953             if(interleaved_stats){
 954                 s->mv_bits+= get_bits_diff(s);
 955             }
 956
 957             /* encode each block */
 958             for (i = 0; i < 6; i++) {
 959                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
 960             }
 961
 962             if(interleaved_stats){
 963                 s->p_tex_bits+= get_bits_diff(s);
 964             }
 965             s->f_count++;
 966         }
 967     } else {
 968         int cbp;
 969         int dc_diff[6];   //dc values with the dc prediction subtracted
 970         int dir[6];  //prediction direction
 971         int zigzag_last_index[6];
 972         uint8_t *scan_table[6];
 973         int i;
 974
 975         for(i=0; i<6; i++){
 976             const int level= block[i][0];
 977             uint16_t *dc_ptr;
 978
 979             dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
 980             if (i < 4) {
 981                 *dc_ptr = level * s->y_dc_scale;
 982             } else {
 983                 *dc_ptr = level * s->c_dc_scale;
 984             }
 985         }
 986
 987         if(s->flags & CODEC_FLAG_AC_PRED){
 988             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
 989             if(!s->ac_pred)
 990                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
 991         }else{
 992             for(i=0; i<6; i++)
 993                 scan_table[i]= s->intra_scantable.permutated;
 994         }
 995
 996         /* compute cbp */
 997         cbp = 0;
 998         for (i = 0; i < 6; i++) {
 999             if (s->block_last_index[i] >= 1)
1000                 cbp |= 1 << (5 - i);
1001         }
1002
1003         cbpc = cbp & 3;
1004         if (s->pict_type == I_TYPE) {
1005             if(s->dquant) cbpc+=4;
1006             put_bits(&s->pb,
1007                 intra_MCBPC_bits[cbpc],
1008                 intra_MCBPC_code[cbpc]);
1009         } else {
1010             if(s->dquant) cbpc+=8;
1011             put_bits(&s->pb, 1, 0);     /* mb coded */
1012             put_bits(&s->pb,
1013                 inter_MCBPC_bits[cbpc + 4],
1014                 inter_MCBPC_code[cbpc + 4]);
1015         }
1016         put_bits(pb2, 1, s->ac_pred);
1017         cbpy = cbp >> 2;
1018         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1019         if(s->dquant)
1020             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1021
1022         if(!s->progressive_sequence){
1023             put_bits(dc_pb, 1, s->interlaced_dct);
1024         }
1025
1026         if(interleaved_stats){
1027             s->misc_bits+= get_bits_diff(s);
1028         }
1029
1030         /* encode each block */
1031         for (i = 0; i < 6; i++) {
1032             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1033         }
1034
1035         if(interleaved_stats){
1036             s->i_tex_bits+= get_bits_diff(s);
1037         }
1038         s->i_count++;
1039
1040         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1041         if(s->ac_pred)
1042             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1043     }
1044 }
1045
1046 void h263_encode_mb(MpegEncContext * s,
1047                     DCTELEM block[6][64],
1048                     int motion_x, int motion_y)
1049 {
1050     int cbpc, cbpy, i, cbp, pred_x, pred_y;
1051     int16_t pred_dc;
1052     int16_t rec_intradc[6];
1053     uint16_t *dc_ptr[6];
1054     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1055     const int dquant_code[5]= {1,0,9,2,3};
1056
1057     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1058     if (!s->mb_intra) {
1059         /* compute cbp */
1060         cbp= get_p_cbp(s, block, motion_x, motion_y);
1061
1062         if ((cbp | motion_x | motion_y | s->dquant) == 0) {
1063             /* skip macroblock */
1064             put_bits(&s->pb, 1, 1);
1065             if(interleaved_stats){
1066                 s->misc_bits++;
1067                 s->last_bits++;
1068             }
1069             return;
1070         }
1071         put_bits(&s->pb, 1, 0); /* mb coded */
1072
1073         cbpc = cbp & 3;
1074         cbpy = cbp >> 2;
1075         if(s->alt_inter_vlc==0 || cbpc!=3)
1076             cbpy ^= 0xF;
1077         if(s->dquant) cbpc+= 8;
1078         if(s->mv_type==MV_TYPE_16X16){
1079             put_bits(&s->pb,
1080                     inter_MCBPC_bits[cbpc],
1081                     inter_MCBPC_code[cbpc]);
1082
1083             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1084             if(s->dquant)
1085                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1086
1087             if(interleaved_stats){
1088                 s->misc_bits+= get_bits_diff(s);
1089             }
1090
1091             /* motion vectors: 16x16 mode */
1092             h263_pred_motion(s, 0, &pred_x, &pred_y);
1093
1094             if (!s->umvplus) {
1095                 h263_encode_motion(s, motion_x - pred_x, s->f_code);
1096                 h263_encode_motion(s, motion_y - pred_y, s->f_code);
1097             }
1098             else {
1099                 h263p_encode_umotion(s, motion_x - pred_x);
1100                 h263p_encode_umotion(s, motion_y - pred_y);
1101                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1102                     /* To prevent Start Code emulation */
1103                     put_bits(&s->pb,1,1);
1104             }
1105         }else{
1106             put_bits(&s->pb,
1107                     inter_MCBPC_bits[cbpc+16],
1108                     inter_MCBPC_code[cbpc+16]);
1109             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1110             if(s->dquant)
1111                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1112
1113             if(interleaved_stats){
1114                 s->misc_bits+= get_bits_diff(s);
1115             }
1116
1117             for(i=0; i<4; i++){
1118                 /* motion vectors: 8x8 mode*/
1119                 h263_pred_motion(s, i, &pred_x, &pred_y);
1120
1121                 motion_x= s->motion_val[ s->block_index[i] ][0];
1122                 motion_y= s->motion_val[ s->block_index[i] ][1];
1123                 if (!s->umvplus) {
1124                     h263_encode_motion(s, motion_x - pred_x, s->f_code);
1125                     h263_encode_motion(s, motion_y - pred_y, s->f_code);
1126                 }
1127                 else {
1128                     h263p_encode_umotion(s, motion_x - pred_x);
1129                     h263p_encode_umotion(s, motion_y - pred_y);
1130                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1131                         /* To prevent Start Code emulation */
1132                         put_bits(&s->pb,1,1);
1133                 }
1134             }
1135         }
1136
1137         if(interleaved_stats){
1138             s->mv_bits+= get_bits_diff(s);
1139         }
1140     } else {
1141         int li = s->h263_aic ? 0 : 1;
1142         assert(s->mb_intra);
1143
1144         cbp = 0;
1145         for(i=0; i<6; i++) {
1146             /* Predict DC */
1147             if (s->h263_aic) {
1148                 int16_t level = block[i][0];
1149
1150                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1151                 level -= pred_dc;
1152                 /* Quant */
1153                 if (level < 0)
1154                     level = (level + (s->qscale >> 1))/(s->y_dc_scale);
1155                 else
1156                     level = (level - (s->qscale >> 1))/(s->y_dc_scale);
1157
1158                 /* AIC can change CBP */
1159                 if (level == 0 && s->block_last_index[i] == 0)
1160                     s->block_last_index[i] = -1;
1161                 else if (level < -127)
1162                     level = -127;
1163                 else if (level > 127)
1164                     level = 127;
1165
1166                 block[i][0] = level;
1167                 /* Reconstruction */
1168                 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
1169                 /* Oddify */
1170                 rec_intradc[i] |= 1;
1171                 //if ((rec_intradc[i] % 2) == 0)
1172                 //    rec_intradc[i]++;
1173                 /* Clipping */
1174                 if (rec_intradc[i] < 0)
1175                     rec_intradc[i] = 0;
1176                 else if (rec_intradc[i] > 2047)
1177                     rec_intradc[i] = 2047;
1178
1179                 /* Update AC/DC tables */
1180                 *dc_ptr[i] = rec_intradc[i];
1181             }
1182             /* compute cbp */
1183             if (s->block_last_index[i] >= li)
1184                 cbp |= 1 << (5 - i);
1185         }
1186
1187         cbpc = cbp & 3;
1188         if (s->pict_type == I_TYPE) {
1189             if(s->dquant) cbpc+=4;
1190             put_bits(&s->pb,
1191                 intra_MCBPC_bits[cbpc],
1192                 intra_MCBPC_code[cbpc]);
1193         } else {
1194             if(s->dquant) cbpc+=8;
1195             put_bits(&s->pb, 1, 0);     /* mb coded */
1196             put_bits(&s->pb,
1197                 inter_MCBPC_bits[cbpc + 4],
1198                 inter_MCBPC_code[cbpc + 4]);
1199         }
1200         if (s->h263_aic) {
1201             /* XXX: currently, we do not try to use ac prediction */
1202             put_bits(&s->pb, 1, 0);     /* no AC prediction */
1203         }
1204         cbpy = cbp >> 2;
1205         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1206         if(s->dquant)
1207             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1208
1209         if(interleaved_stats){
1210             s->misc_bits+= get_bits_diff(s);
1211         }
1212     }
1213
1214     for(i=0; i<6; i++) {
1215         /* encode each block */
1216         h263_encode_block(s, block[i], i);
1217
1218         /* Update INTRADC for decoding */
1219         if (s->h263_aic && s->mb_intra) {
1220             block[i][0] = rec_intradc[i];
1221
1222         }
1223     }
1224
1225     if(interleaved_stats){
1226         if (!s->mb_intra) {
1227             s->p_tex_bits+= get_bits_diff(s);
1228             s->f_count++;
1229         }else{
1230             s->i_tex_bits+= get_bits_diff(s);
1231             s->i_count++;
1232         }
1233     }
1234 }
1235 #endif
1236
1237 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1238 {
1239     int x, y, wrap, a, c, pred_dc, scale;
1240     int16_t *dc_val, *ac_val;
1241
1242     /* find prediction */
1243     if (n < 4) {
1244         x = 2 * s->mb_x + 1 + (n & 1);
1245         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1246         wrap = s->mb_width * 2 + 2;
1247         dc_val = s->dc_val[0];
1248         ac_val = s->ac_val[0][0];
1249         scale = s->y_dc_scale;
1250     } else {
1251         x = s->mb_x + 1;
1252         y = s->mb_y + 1;
1253         wrap = s->mb_width + 2;
1254         dc_val = s->dc_val[n - 4 + 1];
1255         ac_val = s->ac_val[n - 4 + 1][0];
1256         scale = s->c_dc_scale;
1257     }
1258     /* B C
1259      * A X
1260      */
1261     a = dc_val[(x - 1) + (y) * wrap];
1262     c = dc_val[(x) + (y - 1) * wrap];
1263
1264     /* No prediction outside GOB boundary */
1265     if (s->first_slice_line && ((n < 2) || (n > 3)))
1266         c = 1024;
1267     pred_dc = 1024;
1268     /* just DC prediction */
1269     if (a != 1024 && c != 1024)
1270         pred_dc = (a + c) >> 1;
1271     else if (a != 1024)
1272         pred_dc = a;
1273     else
1274         pred_dc = c;
1275
1276     /* we assume pred is positive */
1277     //pred_dc = (pred_dc + (scale >> 1)) / scale;
1278     *dc_val_ptr = &dc_val[x + y * wrap];
1279     return pred_dc;
1280 }
1281
1282 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1283 {
1284     int x, y, wrap, a, c, pred_dc, scale, i;
1285     int16_t *dc_val, *ac_val, *ac_val1;
1286
1287     /* find prediction */
1288     if (n < 4) {
1289         x = 2 * s->mb_x + 1 + (n & 1);
1290         y = 2 * s->mb_y + 1 + (n>> 1);
1291         wrap = s->mb_width * 2 + 2;
1292         dc_val = s->dc_val[0];
1293         ac_val = s->ac_val[0][0];
1294         scale = s->y_dc_scale;
1295     } else {
1296         x = s->mb_x + 1;
1297         y = s->mb_y + 1;
1298         wrap = s->mb_width + 2;
1299         dc_val = s->dc_val[n - 4 + 1];
1300         ac_val = s->ac_val[n - 4 + 1][0];
1301         scale = s->c_dc_scale;
1302     }
1303
1304     ac_val += ((y) * wrap + (x)) * 16;
1305     ac_val1 = ac_val;
1306
1307     /* B C
1308      * A X
1309      */
1310     a = dc_val[(x - 1) + (y) * wrap];
1311     c = dc_val[(x) + (y - 1) * wrap];
1312
1313     /* No prediction outside GOB boundary */
1314     if(s->first_slice_line && n!=3){
1315         if(n!=2) c= 1024;
1316         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1317     }
1318
1319     if (s->ac_pred) {
1320         pred_dc = 1024;
1321         if (s->h263_aic_dir) {
1322             /* left prediction */
1323             if (a != 1024) {
1324                 ac_val -= 16;
1325                 for(i=1;i<8;i++) {
1326                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1327                 }
1328                 pred_dc = a;
1329             }
1330         } else {
1331             /* top prediction */
1332             if (c != 1024) {
1333                 ac_val -= 16 * wrap;
1334                 for(i=1;i<8;i++) {
1335                     block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1336                 }
1337                 pred_dc = c;
1338             }
1339         }
1340     } else {
1341         /* just DC prediction */
1342         if (a != 1024 && c != 1024)
1343             pred_dc = (a + c) >> 1;
1344         else if (a != 1024)
1345             pred_dc = a;
1346         else
1347             pred_dc = c;
1348     }
1349
1350     /* we assume pred is positive */
1351     block[0]=block[0]*scale + pred_dc;
1352
1353     if (block[0] < 0)
1354         block[0] = 0;
1355     else
1356         block[0] |= 1;
1357
1358     /* Update AC/DC tables */
1359     dc_val[(x) + (y) * wrap] = block[0];
1360
1361     /* left copy */
1362     for(i=1;i<8;i++)
1363         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1364     /* top copy */
1365     for(i=1;i<8;i++)
1366         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1367 }
1368
1369 int16_t *h263_pred_motion(MpegEncContext * s, int block,
1370                         int *px, int *py)
1371 {
1372     int xy, wrap;
1373     int16_t *A, *B, *C, *mot_val;
1374     static const int off[4]= {2, 1, 1, -1};
1375
1376     wrap = s->block_wrap[0];
1377     xy = s->block_index[block];
1378
1379     mot_val = s->motion_val[xy];
1380
1381     A = s->motion_val[xy - 1];
1382     /* special case for first (slice) line */
1383     if (s->first_slice_line && block<3) {
1384         // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1385         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1386         if(block==0){ //most common case
1387             if(s->mb_x  == s->resync_mb_x){ //rare
1388                 *px= *py = 0;
1389             }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1390                 C = s->motion_val[xy + off[block] - wrap];
1391                 if(s->mb_x==0){
1392                     *px = C[0];
1393                     *py = C[1];
1394                 }else{
1395                     *px = mid_pred(A[0], 0, C[0]);
1396                     *py = mid_pred(A[1], 0, C[1]);
1397                 }
1398             }else{
1399                 *px = A[0];
1400                 *py = A[1];
1401             }
1402         }else if(block==1){
1403             if(s->mb_x + 1 == s->resync_mb_x){ //rare
1404                 C = s->motion_val[xy + off[block] - wrap];
1405                 *px = mid_pred(A[0], 0, C[0]);
1406                 *py = mid_pred(A[1], 0, C[1]);
1407             }else{
1408                 *px = A[0];
1409                 *py = A[1];
1410             }
1411         }else{ /* block==2*/
1412             B = s->motion_val[xy - wrap];
1413             C = s->motion_val[xy + off[block] - wrap];
1414             if(s->mb_x == s->resync_mb_x) //rare
1415                 A[0]=A[1]=0;
1416
1417             *px = mid_pred(A[0], B[0], C[0]);
1418             *py = mid_pred(A[1], B[1], C[1]);
1419         }
1420     } else {
1421         B = s->motion_val[xy - wrap];
1422         C = s->motion_val[xy + off[block] - wrap];
1423         *px = mid_pred(A[0], B[0], C[0]);
1424         *py = mid_pred(A[1], B[1], C[1]);
1425     }
1426     return mot_val;
1427 }
1428
1429 #ifdef CONFIG_ENCODERS
1430 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1431 {
1432     int range, l, bit_size, sign, code, bits;
1433
1434     if (val == 0) {
1435         /* zero vector */
1436         code = 0;
1437         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1438     } else {
1439         bit_size = f_code - 1;
1440         range = 1 << bit_size;
1441         /* modulo encoding */
1442         l = range * 32;
1443 #if 1
1444         val+= l;
1445         val&= 2*l-1;
1446         val-= l;
1447         sign = val>>31;
1448         val= (val^sign)-sign;
1449         sign&=1;
1450 #else
1451         if (val < -l) {
1452             val += 2*l;
1453         } else if (val >= l) {
1454             val -= 2*l;
1455         }
1456
1457         assert(val>=-l && val<l);
1458
1459         if (val >= 0) {
1460             sign = 0;
1461         } else {
1462             val = -val;
1463             sign = 1;
1464         }
1465 #endif
1466         val--;
1467         code = (val >> bit_size) + 1;
1468         bits = val & (range - 1);
1469
1470         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1471         if (bit_size > 0) {
1472             put_bits(&s->pb, bit_size, bits);
1473         }
1474     }
1475
1476 }
1477
1478 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1479 static void h263p_encode_umotion(MpegEncContext * s, int val)
1480 {
1481     short sval = 0;
1482     short i = 0;
1483     short n_bits = 0;
1484     short temp_val;
1485     int code = 0;
1486     int tcode;
1487
1488     if ( val == 0)
1489         put_bits(&s->pb, 1, 1);
1490     else if (val == 1)
1491         put_bits(&s->pb, 3, 0);
1492     else if (val == -1)
1493         put_bits(&s->pb, 3, 2);
1494     else {
1495
1496         sval = ((val < 0) ? (short)(-val):(short)val);
1497         temp_val = sval;
1498
1499         while (temp_val != 0) {
1500             temp_val = temp_val >> 1;
1501             n_bits++;
1502         }
1503
1504         i = n_bits - 1;
1505         while (i > 0) {
1506             tcode = (sval & (1 << (i-1))) >> (i-1);
1507             tcode = (tcode << 1) | 1;
1508             code = (code << 2) | tcode;
1509             i--;
1510         }
1511         code = ((code << 1) | (val < 0)) << 1;
1512         put_bits(&s->pb, (2*n_bits)+1, code);
1513         //printf("\nVal = %d\tCode = %d", sval, code);
1514     }
1515 }
1516
1517 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1518 {
1519     int f_code;
1520     int mv;
1521
1522     if(mv_penalty==NULL)
1523         mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1524
1525     for(f_code=1; f_code<=MAX_FCODE; f_code++){
1526         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1527             int len;
1528
1529             if(mv==0) len= mvtab[0][1];
1530             else{
1531                 int val, bit_size, range, code;
1532
1533                 bit_size = s->f_code - 1;
1534                 range = 1 << bit_size;
1535
1536                 val=mv;
1537                 if (val < 0)
1538                     val = -val;
1539                 val--;
1540                 code = (val >> bit_size) + 1;
1541                 if(code<33){
1542                     len= mvtab[code][1] + 1 + bit_size;
1543                 }else{
1544                     len= mvtab[32][1] + 2 + bit_size;
1545                 }
1546             }
1547
1548             mv_penalty[f_code][mv+MAX_MV]= len;
1549         }
1550     }
1551
1552     for(f_code=MAX_FCODE; f_code>0; f_code--){
1553         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1554             fcode_tab[mv+MAX_MV]= f_code;
1555         }
1556     }
1557
1558     for(mv=0; mv<MAX_MV*2+1; mv++){
1559         umv_fcode_tab[mv]= 1;
1560     }
1561 }
1562 #endif
1563
1564 #ifdef CONFIG_ENCODERS
1565
1566 static void init_uni_dc_tab(void)
1567 {
1568     int level, uni_code, uni_len;
1569
1570     for(level=-256; level<256; level++){
1571         int size, v, l;
1572         /* find number of bits */
1573         size = 0;
1574         v = abs(level);
1575         while (v) {
1576             v >>= 1;
1577             size++;
1578         }
1579
1580         if (level < 0)
1581             l= (-level) ^ ((1 << size) - 1);
1582         else
1583             l= level;
1584
1585         /* luminance */
1586         uni_code= DCtab_lum[size][0];
1587         uni_len = DCtab_lum[size][1];
1588
1589         if (size > 0) {
1590             uni_code<<=size; uni_code|=l;
1591             uni_len+=size;
1592             if (size > 8){
1593                 uni_code<<=1; uni_code|=1;
1594                 uni_len++;
1595             }
1596         }
1597         uni_DCtab_lum_bits[level+256]= uni_code;
1598         uni_DCtab_lum_len [level+256]= uni_len;
1599
1600         /* chrominance */
1601         uni_code= DCtab_chrom[size][0];
1602         uni_len = DCtab_chrom[size][1];
1603
1604         if (size > 0) {
1605             uni_code<<=size; uni_code|=l;
1606             uni_len+=size;
1607             if (size > 8){
1608                 uni_code<<=1; uni_code|=1;
1609                 uni_len++;
1610             }
1611         }
1612         uni_DCtab_chrom_bits[level+256]= uni_code;
1613         uni_DCtab_chrom_len [level+256]= uni_len;
1614
1615     }
1616 }
1617
1618 #endif //CONFIG_ENCODERS
1619
1620 #ifdef CONFIG_ENCODERS
1621 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1622     int slevel, run, last;
1623
1624     assert(MAX_LEVEL >= 64);
1625     assert(MAX_RUN   >= 63);
1626
1627     for(slevel=-64; slevel<64; slevel++){
1628         if(slevel==0) continue;
1629         for(run=0; run<64; run++){
1630             for(last=0; last<=1; last++){
1631                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1632                 int level= slevel < 0 ? -slevel : slevel;
1633                 int sign= slevel < 0 ? 1 : 0;
1634                 int bits, len, code;
1635                 int level1, run1;
1636
1637                 len_tab[index]= 100;
1638
1639                 /* ESC0 */
1640                 code= get_rl_index(rl, last, run, level);
1641                 bits= rl->table_vlc[code][0];
1642                 len=  rl->table_vlc[code][1];
1643                 bits=bits*2+sign; len++;
1644
1645                 if(code!=rl->n && len < len_tab[index]){
1646                     bits_tab[index]= bits;
1647                     len_tab [index]= len;
1648                 }
1649 #if 1
1650                 /* ESC1 */
1651                 bits= rl->table_vlc[rl->n][0];
1652                 len=  rl->table_vlc[rl->n][1];
1653                 bits=bits*2;    len++; //esc1
1654                 level1= level - rl->max_level[last][run];
1655                 if(level1>0){
1656                     code= get_rl_index(rl, last, run, level1);
1657                     bits<<= rl->table_vlc[code][1];
1658                     len  += rl->table_vlc[code][1];
1659                     bits += rl->table_vlc[code][0];
1660                     bits=bits*2+sign; len++;
1661
1662                     if(code!=rl->n && len < len_tab[index]){
1663                         bits_tab[index]= bits;
1664                         len_tab [index]= len;
1665                     }
1666                 }
1667 #endif
1668 #if 1
1669                 /* ESC2 */
1670                 bits= rl->table_vlc[rl->n][0];
1671                 len=  rl->table_vlc[rl->n][1];
1672                 bits=bits*4+2;    len+=2; //esc2
1673                 run1 = run - rl->max_run[last][level] - 1;
1674                 if(run1>=0){
1675                     code= get_rl_index(rl, last, run1, level);
1676                     bits<<= rl->table_vlc[code][1];
1677                     len  += rl->table_vlc[code][1];
1678                     bits += rl->table_vlc[code][0];
1679                     bits=bits*2+sign; len++;
1680
1681                     if(code!=rl->n && len < len_tab[index]){
1682                         bits_tab[index]= bits;
1683                         len_tab [index]= len;
1684                     }
1685                 }
1686 #endif
1687                 /* ESC3 */
1688                 bits= rl->table_vlc[rl->n][0];
1689                 len = rl->table_vlc[rl->n][1];
1690                 bits=bits*4+3;    len+=2; //esc3
1691                 bits=bits*2+last; len++;
1692                 bits=bits*64+run; len+=6;
1693                 bits=bits*2+1;    len++;  //marker
1694                 bits=bits*4096+(slevel&0xfff); len+=12;
1695                 bits=bits*2+1;    len++;  //marker
1696
1697                 if(len < len_tab[index]){
1698                     bits_tab[index]= bits;
1699                     len_tab [index]= len;
1700                 }
1701             }
1702         }
1703     }
1704 }
1705
1706 void h263_encode_init(MpegEncContext *s)
1707 {
1708     static int done = 0;
1709
1710     if (!done) {
1711         done = 1;
1712
1713         init_uni_dc_tab();
1714
1715         init_rl(&rl_inter);
1716         init_rl(&rl_intra);
1717         init_rl(&rl_intra_aic);
1718
1719         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1720         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1721
1722         init_mv_penalty_and_fcode(s);
1723     }
1724     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1725
1726     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1727     switch(s->codec_id){
1728     case CODEC_ID_MPEG4:
1729         s->fcode_tab= fcode_tab;
1730         s->min_qcoeff= -2048;
1731         s->max_qcoeff=  2047;
1732         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
1733         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1734         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
1735         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1736         s->luma_dc_vlc_length= uni_DCtab_lum_len;
1737         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1738         s->ac_esc_length= 7+2+1+6+1+12+1;
1739
1740         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1741
1742             s->avctx->extradata= av_malloc(1024);
1743             init_put_bits(&s->pb, s->avctx->extradata, 1024);
1744
1745             mpeg4_encode_visual_object_header(s);
1746             mpeg4_encode_vol_header(s, 0, 0);
1747
1748 //            ff_mpeg4_stuffing(&s->pb); ?
1749             flush_put_bits(&s->pb);
1750             s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3;
1751         }
1752
1753         break;
1754     case CODEC_ID_H263P:
1755         s->fcode_tab= umv_fcode_tab;
1756         s->min_qcoeff= -127;
1757         s->max_qcoeff=  127;
1758         break;
1759         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1760     case CODEC_ID_FLV1:
1761         if (s->h263_flv > 1) {
1762             s->min_qcoeff= -1023;
1763             s->max_qcoeff=  1023;
1764         } else {
1765             s->min_qcoeff= -127;
1766             s->max_qcoeff=  127;
1767         }
1768         s->y_dc_scale_table=
1769         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1770         break;
1771     default: //nothing needed default table allready set in mpegvideo.c
1772         s->min_qcoeff= -127;
1773         s->max_qcoeff=  127;
1774         s->y_dc_scale_table=
1775         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1776     }
1777 }
1778
1779 /**
1780  * encodes a 8x8 block.
1781  * @param block the 8x8 block
1782  * @param n block index (0-3 are luma, 4-5 are chroma)
1783  */
1784 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1785 {
1786     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1787     RLTable *rl;
1788
1789     rl = &rl_inter;
1790     if (s->mb_intra && !s->h263_aic) {
1791         /* DC coef */
1792         level = block[0];
1793         /* 255 cannot be represented, so we clamp */
1794         if (level > 254) {
1795             level = 254;
1796             block[0] = 254;
1797         }
1798         /* 0 cannot be represented also */
1799         else if (level < 1) {
1800             level = 1;
1801             block[0] = 1;
1802         }
1803         if (level == 128) //FIXME check rv10
1804             put_bits(&s->pb, 8, 0xff);
1805         else
1806             put_bits(&s->pb, 8, level & 0xff);
1807         i = 1;
1808     } else {
1809         i = 0;
1810         if (s->h263_aic && s->mb_intra)
1811             rl = &rl_intra_aic;
1812
1813         if(s->alt_inter_vlc && !s->mb_intra){
1814             int aic_vlc_bits=0;
1815             int inter_vlc_bits=0;
1816             int wrong_pos=-1;
1817             int aic_code;
1818
1819             last_index = s->block_last_index[n];
1820             last_non_zero = i - 1;
1821             for (; i <= last_index; i++) {
1822                 j = s->intra_scantable.permutated[i];
1823                 level = block[j];
1824                 if (level) {
1825                     run = i - last_non_zero - 1;
1826                     last = (i == last_index);
1827
1828                     code = get_rl_index(rl, last, run, level);
1829                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
1830                     inter_vlc_bits += rl->table_vlc[code][1]+1;
1831                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
1832
1833                     if (code == rl->n) {
1834                         inter_vlc_bits += 1+6+8;
1835                     }
1836                     if (aic_code == rl_intra_aic.n) {
1837                         aic_vlc_bits += 1+6+8;
1838                         wrong_pos += run + 1;
1839                     }else
1840                         wrong_pos += wrong_run[aic_code];
1841                     last_non_zero = i;
1842                 }
1843             }
1844             i = 0;
1845             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
1846                 rl = &rl_intra_aic;
1847         }
1848     }
1849
1850     /* AC coefs */
1851     last_index = s->block_last_index[n];
1852     last_non_zero = i - 1;
1853     for (; i <= last_index; i++) {
1854         j = s->intra_scantable.permutated[i];
1855         level = block[j];
1856         if (level) {
1857             run = i - last_non_zero - 1;
1858             last = (i == last_index);
1859             sign = 0;
1860             slevel = level;
1861             if (level < 0) {
1862                 sign = 1;
1863                 level = -level;
1864             }
1865             code = get_rl_index(rl, last, run, level);
1866             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1867             if (code == rl->n) {
1868               if(s->h263_flv <= 1){
1869                 put_bits(&s->pb, 1, last);
1870                 put_bits(&s->pb, 6, run);
1871
1872                 assert(slevel != 0);
1873
1874                 if(slevel < 128 && slevel > -128)
1875                     put_bits(&s->pb, 8, slevel & 0xff);
1876                 else{
1877                     put_bits(&s->pb, 8, 128);
1878                     put_bits(&s->pb, 5, slevel & 0x1f);
1879                     put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1880                 }
1881               }else{
1882                     if(slevel < 64 && slevel > -64) {
1883                         /* 7-bit level */
1884                         put_bits(&s->pb, 1, 0);
1885                         put_bits(&s->pb, 1, last);
1886                         put_bits(&s->pb, 6, run);
1887
1888                         put_bits(&s->pb, 7, slevel & 0x7f);
1889                     } else {
1890                         /* 11-bit level */
1891                         put_bits(&s->pb, 1, 1);
1892                         put_bits(&s->pb, 1, last);
1893                         put_bits(&s->pb, 6, run);
1894
1895                         put_bits(&s->pb, 11, slevel & 0x7ff);
1896                     }
1897               }
1898             } else {
1899                 put_bits(&s->pb, 1, sign);
1900             }
1901             last_non_zero = i;
1902         }
1903     }
1904 }
1905 #endif
1906
1907 #ifdef CONFIG_ENCODERS
1908
1909 /***************************************************/
1910 /**
1911  * add mpeg4 stuffing bits (01...1)
1912  */
1913 void ff_mpeg4_stuffing(PutBitContext * pbc)
1914 {
1915     int length;
1916     put_bits(pbc, 1, 0);
1917     length= (-get_bit_count(pbc))&7;
1918     if(length) put_bits(pbc, length, (1<<length)-1);
1919 }
1920
1921 /* must be called before writing the header */
1922 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1923     int time_div, time_mod;
1924
1925     if(s->current_picture_ptr->pts)
1926         s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1927     else
1928         s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1929     time_div= s->time/s->time_increment_resolution;
1930     time_mod= s->time%s->time_increment_resolution;
1931
1932     if(s->pict_type==B_TYPE){
1933         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1934     }else{
1935         s->last_time_base= s->time_base;
1936         s->time_base= time_div;
1937         s->pp_time= s->time - s->last_non_b_time;
1938         s->last_non_b_time= s->time;
1939     }
1940 }
1941
1942 static void mpeg4_encode_gop_header(MpegEncContext * s){
1943     int hours, minutes, seconds;
1944
1945     put_bits(&s->pb, 16, 0);
1946     put_bits(&s->pb, 16, GOP_STARTCODE);
1947
1948     seconds= s->time/s->time_increment_resolution;
1949     minutes= seconds/60; seconds %= 60;
1950     hours= minutes/60; minutes %= 60;
1951     hours%=24;
1952
1953     put_bits(&s->pb, 5, hours);
1954     put_bits(&s->pb, 6, minutes);
1955     put_bits(&s->pb, 1, 1);
1956     put_bits(&s->pb, 6, seconds);
1957
1958     put_bits(&s->pb, 1, 0); //closed gov == NO
1959     put_bits(&s->pb, 1, 0); //broken link == NO
1960
1961     ff_mpeg4_stuffing(&s->pb);
1962 }
1963
1964 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1965     int profile_and_level_indication;
1966     int vo_ver_id;
1967
1968     if(s->max_b_frames || s->quarter_sample){
1969         profile_and_level_indication= 0xF1; // adv simple level 1
1970         vo_ver_id= 5;
1971     }else{
1972         profile_and_level_indication= 0x01; // simple level 1
1973         vo_ver_id= 1;
1974     }
1975     //FIXME levels
1976
1977     put_bits(&s->pb, 16, 0);
1978     put_bits(&s->pb, 16, VOS_STARTCODE);
1979
1980     put_bits(&s->pb, 8, profile_and_level_indication);
1981
1982     put_bits(&s->pb, 16, 0);
1983     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1984
1985     put_bits(&s->pb, 1, 1);
1986         put_bits(&s->pb, 4, vo_ver_id);
1987         put_bits(&s->pb, 3, 1); //priority
1988
1989     put_bits(&s->pb, 4, 1); //visual obj type== video obj
1990
1991     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1992
1993     ff_mpeg4_stuffing(&s->pb);
1994 }
1995
1996 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1997 {
1998     int vo_ver_id;
1999
2000     if(s->max_b_frames || s->quarter_sample){
2001         vo_ver_id= 5;
2002         s->vo_type= ADV_SIMPLE_VO_TYPE;
2003     }else{
2004         vo_ver_id= 1;
2005         s->vo_type= SIMPLE_VO_TYPE;
2006     }
2007
2008     put_bits(&s->pb, 16, 0);
2009     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2010     put_bits(&s->pb, 16, 0);
2011     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2012
2013     put_bits(&s->pb, 1, 0);             /* random access vol */
2014     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2015     put_bits(&s->pb, 1, 1);             /* is obj layer id= yes */
2016       put_bits(&s->pb, 4, vo_ver_id);   /* is obj layer ver id */
2017       put_bits(&s->pb, 3, 1);           /* is obj layer priority */
2018
2019     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2020
2021     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2022     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2023         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2024         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2025     }
2026
2027     if(s->low_delay){
2028         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2029         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2030         put_bits(&s->pb, 1, s->low_delay);
2031         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2032     }else{
2033         put_bits(&s->pb, 1, 0);         /* vol control parameters= no */
2034     }
2035
2036     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2037     put_bits(&s->pb, 1, 1);             /* marker bit */
2038
2039     put_bits(&s->pb, 16, s->time_increment_resolution);
2040     if (s->time_increment_bits < 1)
2041         s->time_increment_bits = 1;
2042     put_bits(&s->pb, 1, 1);             /* marker bit */
2043     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2044     put_bits(&s->pb, 1, 1);             /* marker bit */
2045     put_bits(&s->pb, 13, s->width);     /* vol width */
2046     put_bits(&s->pb, 1, 1);             /* marker bit */
2047     put_bits(&s->pb, 13, s->height);    /* vol height */
2048     put_bits(&s->pb, 1, 1);             /* marker bit */
2049     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2050     put_bits(&s->pb, 1, 1);             /* obmc disable */
2051     if (vo_ver_id == 1) {
2052         put_bits(&s->pb, 1, s->vol_sprite_usage=0);             /* sprite enable */
2053     }else{
2054         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
2055     }
2056
2057     s->quant_precision=5;
2058     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2059     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2060
2061     if(s->mpeg_quant){
2062         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2063         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2064     }
2065
2066     if (vo_ver_id != 1)
2067         put_bits(&s->pb, 1, s->quarter_sample);
2068     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2069     s->resync_marker= s->rtp_mode;
2070     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2071     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2072     if(s->data_partitioning){
2073         put_bits(&s->pb, 1, 0);         /* no rvlc */
2074     }
2075
2076     if (vo_ver_id != 1){
2077         put_bits(&s->pb, 1, 0);         /* newpred */
2078         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2079     }
2080     put_bits(&s->pb, 1, 0);             /* scalability */
2081
2082     ff_mpeg4_stuffing(&s->pb);
2083
2084     /* user data */
2085     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2086         put_bits(&s->pb, 16, 0);
2087         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2088         put_string(&s->pb, LIBAVCODEC_IDENT);
2089         ff_mpeg4_stuffing(&s->pb);
2090     }
2091 }
2092
2093 /* write mpeg4 VOP header */
2094 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2095 {
2096     int time_incr;
2097     int time_div, time_mod;
2098
2099     if(s->pict_type==I_TYPE){
2100         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2101             if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2102                 mpeg4_encode_visual_object_header(s);
2103             if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2104                 mpeg4_encode_vol_header(s, 0, 0);
2105         }
2106         mpeg4_encode_gop_header(s);
2107     }
2108
2109     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2110
2111 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2112
2113     put_bits(&s->pb, 16, 0);            /* vop header */
2114     put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2115     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
2116
2117     time_div= s->time/s->time_increment_resolution;
2118     time_mod= s->time%s->time_increment_resolution;
2119     time_incr= time_div - s->last_time_base;
2120     while(time_incr--)
2121         put_bits(&s->pb, 1, 1);
2122
2123     put_bits(&s->pb, 1, 0);
2124
2125     put_bits(&s->pb, 1, 1);     /* marker */
2126     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2127     put_bits(&s->pb, 1, 1);     /* marker */
2128     put_bits(&s->pb, 1, 1);     /* vop coded */
2129     if (    s->pict_type == P_TYPE
2130         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2131         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2132     }
2133     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2134     if(!s->progressive_sequence){
2135          put_bits(&s->pb, 1, s->top_field_first);
2136          put_bits(&s->pb, 1, s->alternate_scan);
2137     }
2138     //FIXME sprite stuff
2139
2140     put_bits(&s->pb, 5, s->qscale);
2141
2142     if (s->pict_type != I_TYPE)
2143         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2144     if (s->pict_type == B_TYPE)
2145         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2146     //    printf("****frame %d\n", picture_number);
2147
2148      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
2149      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2150 }
2151
2152 #endif //CONFIG_ENCODERS
2153
2154 /**
2155  * change qscale by given dquant and update qscale dependant variables.
2156  */
2157 static void change_qscale(MpegEncContext * s, int dquant)
2158 {
2159     s->qscale += dquant;
2160
2161     if (s->qscale < 1)
2162         s->qscale = 1;
2163     else if (s->qscale > 31)
2164         s->qscale = 31;
2165
2166     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2167     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2168 }
2169
2170 /**
2171  * predicts the dc.
2172  * @param n block index (0-3 are luma, 4-5 are chroma)
2173  * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2174  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2175  * @return the quantized predicted dc
2176  */
2177 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2178 {
2179     int a, b, c, wrap, pred, scale;
2180     uint16_t *dc_val;
2181
2182     /* find prediction */
2183     if (n < 4) {
2184         scale = s->y_dc_scale;
2185     } else {
2186         scale = s->c_dc_scale;
2187     }
2188     if(IS_3IV1)
2189         scale= 8;
2190
2191     wrap= s->block_wrap[n];
2192     dc_val = s->dc_val[0] + s->block_index[n];
2193
2194     /* B C
2195      * A X
2196      */
2197     a = dc_val[ - 1];
2198     b = dc_val[ - 1 - wrap];
2199     c = dc_val[ - wrap];
2200
2201     /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2202     if(s->first_slice_line && n!=3){
2203         if(n!=2) b=c= 1024;
2204         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2205     }
2206     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2207         if(n==0 || n==4 || n==5)
2208             b=1024;
2209     }
2210
2211     if (abs(a - b) < abs(b - c)) {
2212         pred = c;
2213         *dir_ptr = 1; /* top */
2214     } else {
2215         pred = a;
2216         *dir_ptr = 0; /* left */
2217     }
2218     /* we assume pred is positive */
2219     pred = FASTDIV((pred + (scale >> 1)), scale);
2220
2221     /* prepare address for prediction update */
2222     *dc_val_ptr = &dc_val[0];
2223
2224     return pred;
2225 }
2226
2227 /**
2228  * predicts the ac.
2229  * @param n block index (0-3 are luma, 4-5 are chroma)
2230  * @param dir the ac prediction direction
2231  */
2232 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2233                    int dir)
2234 {
2235     int i;
2236     int16_t *ac_val, *ac_val1;
2237     int8_t * const qscale_table= s->current_picture.qscale_table;
2238
2239     /* find prediction */
2240     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2241     ac_val1 = ac_val;
2242     if (s->ac_pred) {
2243         if (dir == 0) {
2244             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2245             /* left prediction */
2246             ac_val -= 16;
2247
2248             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2249                 /* same qscale */
2250                 for(i=1;i<8;i++) {
2251                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2252                 }
2253             }else{
2254                 /* different qscale, we must rescale */
2255                 for(i=1;i<8;i++) {
2256                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2257                 }
2258             }
2259         } else {
2260             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2261             /* top prediction */
2262             ac_val -= 16 * s->block_wrap[n];
2263
2264             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2265                 /* same qscale */
2266                 for(i=1;i<8;i++) {
2267                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2268                 }
2269             }else{
2270                 /* different qscale, we must rescale */
2271                 for(i=1;i<8;i++) {
2272                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2273                 }
2274             }
2275         }
2276     }
2277     /* left copy */
2278     for(i=1;i<8;i++)
2279         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2280
2281     /* top copy */
2282     for(i=1;i<8;i++)
2283         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2284
2285 }
2286
2287 #ifdef CONFIG_ENCODERS
2288
2289 /**
2290  * encodes the dc value.
2291  * @param n block index (0-3 are luma, 4-5 are chroma)
2292  */
2293 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2294 {
2295 #if 1
2296 //    if(level<-255 || level>255) printf("dc overflow\n");
2297     level+=256;
2298     if (n < 4) {
2299         /* luminance */
2300         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2301     } else {
2302         /* chrominance */
2303         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2304     }
2305 #else
2306     int size, v;
2307     /* find number of bits */
2308     size = 0;
2309     v = abs(level);
2310     while (v) {
2311         v >>= 1;
2312         size++;
2313     }
2314
2315     if (n < 4) {
2316         /* luminance */
2317         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2318     } else {
2319         /* chrominance */
2320         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2321     }
2322
2323     /* encode remaining bits */
2324     if (size > 0) {
2325         if (level < 0)
2326             level = (-level) ^ ((1 << size) - 1);
2327         put_bits(&s->pb, size, level);
2328         if (size > 8)
2329             put_bits(&s->pb, 1, 1);
2330     }
2331 #endif
2332 }
2333
2334 /**
2335  * encodes a 8x8 block
2336  * @param n block index (0-3 are luma, 4-5 are chroma)
2337  */
2338 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2339                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2340 {
2341     int i, last_non_zero;
2342 #if 0 //variables for the outcommented version
2343     int code, sign, last;
2344 #endif
2345     const RLTable *rl;
2346     uint32_t *bits_tab;
2347     uint8_t *len_tab;
2348     const int last_index = s->block_last_index[n];
2349
2350     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2351         /* mpeg4 based DC predictor */
2352         mpeg4_encode_dc(dc_pb, intra_dc, n);
2353         if(last_index<1) return;
2354         i = 1;
2355         rl = &rl_intra;
2356         bits_tab= uni_mpeg4_intra_rl_bits;
2357         len_tab = uni_mpeg4_intra_rl_len;
2358     } else {
2359         if(last_index<0) return;
2360         i = 0;
2361         rl = &rl_inter;
2362         bits_tab= uni_mpeg4_inter_rl_bits;
2363         len_tab = uni_mpeg4_inter_rl_len;
2364     }
2365
2366     /* AC coefs */
2367     last_non_zero = i - 1;
2368 #if 1
2369     for (; i < last_index; i++) {
2370         int level = block[ scan_table[i] ];
2371         if (level) {
2372             int run = i - last_non_zero - 1;
2373             level+=64;
2374             if((level&(~127)) == 0){
2375                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2376                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2377             }else{ //ESC3
2378                 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);
2379             }
2380             last_non_zero = i;
2381         }
2382     }
2383     /*if(i<=last_index)*/{
2384         int level = block[ scan_table[i] ];
2385         int run = i - last_non_zero - 1;
2386         level+=64;
2387         if((level&(~127)) == 0){
2388             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2389             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2390         }else{ //ESC3
2391             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);
2392         }
2393     }
2394 #else
2395     for (; i <= last_index; i++) {
2396         const int slevel = block[ scan_table[i] ];
2397         if (slevel) {
2398             int level;
2399             int run = i - last_non_zero - 1;
2400             last = (i == last_index);
2401             sign = 0;
2402             level = slevel;
2403             if (level < 0) {
2404                 sign = 1;
2405                 level = -level;
2406             }
2407             code = get_rl_index(rl, last, run, level);
2408             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2409             if (code == rl->n) {
2410                 int level1, run1;
2411                 level1 = level - rl->max_level[last][run];
2412                 if (level1 < 1)
2413                     goto esc2;
2414                 code = get_rl_index(rl, last, run, level1);
2415                 if (code == rl->n) {
2416                 esc2:
2417                     put_bits(ac_pb, 1, 1);
2418                     if (level > MAX_LEVEL)
2419                         goto esc3;
2420                     run1 = run - rl->max_run[last][level] - 1;
2421                     if (run1 < 0)
2422                         goto esc3;
2423                     code = get_rl_index(rl, last, run1, level);
2424                     if (code == rl->n) {
2425                     esc3:
2426                         /* third escape */
2427                         put_bits(ac_pb, 1, 1);
2428                         put_bits(ac_pb, 1, last);
2429                         put_bits(ac_pb, 6, run);
2430                         put_bits(ac_pb, 1, 1);
2431                         put_bits(ac_pb, 12, slevel & 0xfff);
2432                         put_bits(ac_pb, 1, 1);
2433                     } else {
2434                         /* second escape */
2435                         put_bits(ac_pb, 1, 0);
2436                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2437                         put_bits(ac_pb, 1, sign);
2438                     }
2439                 } else {
2440                     /* first escape */
2441                     put_bits(ac_pb, 1, 0);
2442                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2443                     put_bits(ac_pb, 1, sign);
2444                 }
2445             } else {
2446                 put_bits(ac_pb, 1, sign);
2447             }
2448             last_non_zero = i;
2449         }
2450     }
2451 #endif
2452 }
2453
2454 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2455                                uint8_t *scan_table)
2456 {
2457     int i, last_non_zero;
2458     const RLTable *rl;
2459     uint8_t *len_tab;
2460     const int last_index = s->block_last_index[n];
2461     int len=0;
2462
2463     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2464         /* mpeg4 based DC predictor */
2465         //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2466         if(last_index<1) return len;
2467         i = 1;
2468         rl = &rl_intra;
2469         len_tab = uni_mpeg4_intra_rl_len;
2470     } else {
2471         if(last_index<0) return 0;
2472         i = 0;
2473         rl = &rl_inter;
2474         len_tab = uni_mpeg4_inter_rl_len;
2475     }
2476
2477     /* AC coefs */
2478     last_non_zero = i - 1;
2479     for (; i < last_index; i++) {
2480         int level = block[ scan_table[i] ];
2481         if (level) {
2482             int run = i - last_non_zero - 1;
2483             level+=64;
2484             if((level&(~127)) == 0){
2485                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2486                 len += len_tab[index];
2487             }else{ //ESC3
2488                 len += 7+2+1+6+1+12+1;
2489             }
2490             last_non_zero = i;
2491         }
2492     }
2493     /*if(i<=last_index)*/{
2494         int level = block[ scan_table[i] ];
2495         int run = i - last_non_zero - 1;
2496         level+=64;
2497         if((level&(~127)) == 0){
2498             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2499             len += len_tab[index];
2500         }else{ //ESC3
2501             len += 7+2+1+6+1+12+1;
2502         }
2503     }
2504
2505     return len;
2506 }
2507
2508 #endif
2509
2510
2511 /***********************************************/
2512 /* decoding */
2513
2514 static VLC intra_MCBPC_vlc;
2515 static VLC inter_MCBPC_vlc;
2516 static VLC cbpy_vlc;
2517 static VLC mv_vlc;
2518 static VLC dc_lum, dc_chrom;
2519 static VLC sprite_trajectory;
2520 static VLC mb_type_b_vlc;
2521
2522 void init_vlc_rl(RLTable *rl)
2523 {
2524     int i, q;
2525
2526     init_vlc(&rl->vlc, 9, rl->n + 1,
2527              &rl->table_vlc[0][1], 4, 2,
2528              &rl->table_vlc[0][0], 4, 2);
2529
2530
2531     for(q=0; q<32; q++){
2532         int qmul= q*2;
2533         int qadd= (q-1)|1;
2534
2535         if(q==0){
2536             qmul=1;
2537             qadd=0;
2538         }
2539
2540         rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2541         for(i=0; i<rl->vlc.table_size; i++){
2542             int code= rl->vlc.table[i][0];
2543             int len = rl->vlc.table[i][1];
2544             int level, run;
2545
2546             if(len==0){ // illegal code
2547                 run= 66;
2548                 level= MAX_LEVEL;
2549             }else if(len<0){ //more bits needed
2550                 run= 0;
2551                 level= code;
2552             }else{
2553                 if(code==rl->n){ //esc
2554                     run= 66;
2555                     level= 0;
2556                 }else{
2557                     run=   rl->table_run  [code] + 1;
2558                     level= rl->table_level[code] * qmul + qadd;
2559                     if(code >= rl->last) run+=192;
2560                 }
2561             }
2562             rl->rl_vlc[q][i].len= len;
2563             rl->rl_vlc[q][i].level= level;
2564             rl->rl_vlc[q][i].run= run;
2565         }
2566     }
2567 }
2568
2569 /* init vlcs */
2570
2571 /* XXX: find a better solution to handle static init */
2572 void h263_decode_init_vlc(MpegEncContext *s)
2573 {
2574     static int done = 0;
2575
2576     if (!done) {
2577         done = 1;
2578
2579         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2580                  intra_MCBPC_bits, 1, 1,
2581                  intra_MCBPC_code, 1, 1);
2582         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2583                  inter_MCBPC_bits, 1, 1,
2584                  inter_MCBPC_code, 1, 1);
2585         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2586                  &cbpy_tab[0][1], 2, 1,
2587                  &cbpy_tab[0][0], 2, 1);
2588         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2589                  &mvtab[0][1], 2, 1,
2590                  &mvtab[0][0], 2, 1);
2591         init_rl(&rl_inter);
2592         init_rl(&rl_intra);
2593         init_rl(&rvlc_rl_inter);
2594         init_rl(&rvlc_rl_intra);
2595         init_rl(&rl_intra_aic);
2596         init_vlc_rl(&rl_inter);
2597         init_vlc_rl(&rl_intra);
2598         init_vlc_rl(&rvlc_rl_inter);
2599         init_vlc_rl(&rvlc_rl_intra);
2600         init_vlc_rl(&rl_intra_aic);
2601         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2602                  &DCtab_lum[0][1], 2, 1,
2603                  &DCtab_lum[0][0], 2, 1);
2604         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2605                  &DCtab_chrom[0][1], 2, 1,
2606                  &DCtab_chrom[0][0], 2, 1);
2607         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2608                  &sprite_trajectory_tab[0][1], 4, 2,
2609                  &sprite_trajectory_tab[0][0], 4, 2);
2610         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2611                  &mb_type_b_tab[0][1], 2, 1,
2612                  &mb_type_b_tab[0][0], 2, 1);
2613     }
2614 }
2615
2616 /**
2617  * Get the GOB height based on picture height.
2618  */
2619 int ff_h263_get_gob_height(MpegEncContext *s){
2620     if (s->height <= 400)
2621         return 1;
2622     else if (s->height <= 800)
2623         return  2;
2624     else
2625         return 4;
2626 }
2627
2628 /**
2629  * decodes the group of blocks header.
2630  * @return <0 if an error occured
2631  */
2632 static int h263_decode_gob_header(MpegEncContext *s)
2633 {
2634     unsigned int val, gfid;
2635     int left;
2636
2637     /* Check for GOB Start Code */
2638     val = show_bits(&s->gb, 16);
2639     if(val)
2640         return -1;
2641
2642         /* We have a GBSC probably with GSTUFF */
2643     skip_bits(&s->gb, 16); /* Drop the zeros */
2644     left= s->gb.size_in_bits - get_bits_count(&s->gb);
2645     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2646     for(;left>13; left--){
2647         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2648     }
2649     if(left<=13)
2650         return -1;
2651
2652 #ifdef DEBUG
2653     fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2654 #endif
2655     s->gob_number = get_bits(&s->gb, 5); /* GN */
2656     gfid = get_bits(&s->gb, 2); /* GFID */
2657     s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2658     if(s->qscale==0)
2659         return -1;
2660     s->mb_x= 0;
2661     s->mb_y= s->gob_index* s->gob_number;
2662     if(s->mb_y >= s->mb_height)
2663         return -1;
2664 #ifdef DEBUG
2665     fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2666 #endif
2667     return 0;
2668 }
2669
2670 static inline void memsetw(short *tab, int val, int n)
2671 {
2672     int i;
2673     for(i=0;i<n;i++)
2674         tab[i] = val;
2675 }
2676
2677 #ifdef CONFIG_ENCODERS
2678
2679 void ff_mpeg4_init_partitions(MpegEncContext *s)
2680 {
2681     init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2682     init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE);
2683 }
2684
2685 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2686 {
2687     const int pb2_len   = get_bit_count(&s->pb2   );
2688     const int tex_pb_len= get_bit_count(&s->tex_pb);
2689     const int bits= get_bit_count(&s->pb);
2690
2691     if(s->pict_type==I_TYPE){
2692         put_bits(&s->pb, 19, DC_MARKER);
2693         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2694         s->i_tex_bits+= tex_pb_len;
2695     }else{
2696         put_bits(&s->pb, 17, MOTION_MARKER);
2697         s->misc_bits+=17 + pb2_len;
2698         s->mv_bits+= bits - s->last_bits;
2699         s->p_tex_bits+= tex_pb_len;
2700     }
2701
2702     flush_put_bits(&s->pb2);
2703     flush_put_bits(&s->tex_pb);
2704
2705     ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2706     ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2707     s->last_bits= get_bit_count(&s->pb);
2708 }
2709
2710 #endif //CONFIG_ENCODERS
2711
2712 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2713     switch(s->pict_type){
2714         case I_TYPE:
2715             return 16;
2716         case P_TYPE:
2717         case S_TYPE:
2718             return s->f_code+15;
2719         case B_TYPE:
2720             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2721         default:
2722             return -1;
2723     }
2724 }
2725
2726 #ifdef CONFIG_ENCODERS
2727
2728 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2729 {
2730     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2731
2732     ff_mpeg4_stuffing(&s->pb);
2733     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2734     put_bits(&s->pb, 1, 1);
2735
2736     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2737     put_bits(&s->pb, s->quant_precision, s->qscale);
2738     put_bits(&s->pb, 1, 0); /* no HEC */
2739 }
2740
2741 #endif //CONFIG_ENCODERS
2742
2743 /**
2744  * check if the next stuff is a resync marker or the end.
2745  * @return 0 if not
2746  */
2747 static inline int mpeg4_is_resync(MpegEncContext *s){
2748     const int bits_count= get_bits_count(&s->gb);
2749
2750     if(s->workaround_bugs&FF_BUG_NO_PADDING){
2751         return 0;
2752     }
2753
2754     if(bits_count + 8 >= s->gb.size_in_bits){
2755         int v= show_bits(&s->gb, 8);
2756         v|= 0x7F >> (7-(bits_count&7));
2757
2758         if(v==0x7F)
2759             return 1;
2760     }else{
2761         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2762             int len;
2763             GetBitContext gb= s->gb;
2764
2765             skip_bits(&s->gb, 1);
2766             align_get_bits(&s->gb);
2767
2768             for(len=0; len<32; len++){
2769                 if(get_bits1(&s->gb)) break;
2770             }
2771
2772             s->gb= gb;
2773
2774             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2775                 return 1;
2776         }
2777     }
2778     return 0;
2779 }
2780
2781 /**
2782  * decodes the next video packet.
2783  * @return <0 if something went wrong
2784  */
2785 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2786 {
2787     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2788     int header_extension=0, mb_num, len;
2789
2790     /* is there enough space left for a video packet + header */
2791     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2792
2793     for(len=0; len<32; len++){
2794         if(get_bits1(&s->gb)) break;
2795     }
2796
2797     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2798         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
2799         return -1;
2800     }
2801
2802     if(s->shape != RECT_SHAPE){
2803         header_extension= get_bits1(&s->gb);
2804         //FIXME more stuff here
2805     }
2806
2807     mb_num= get_bits(&s->gb, mb_num_bits);
2808     if(mb_num>=s->mb_num){
2809         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2810         return -1;
2811     }
2812     if(s->pict_type == B_TYPE){
2813         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2814         if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2815     }
2816
2817     s->mb_x= mb_num % s->mb_width;
2818     s->mb_y= mb_num / s->mb_width;
2819
2820     if(s->shape != BIN_ONLY_SHAPE){
2821         int qscale= get_bits(&s->gb, s->quant_precision);
2822         if(qscale)
2823             s->qscale= qscale;
2824     }
2825
2826     if(s->shape == RECT_SHAPE){
2827         header_extension= get_bits1(&s->gb);
2828     }
2829     if(header_extension){
2830         int time_increment;
2831         int time_incr=0;
2832
2833         while (get_bits1(&s->gb) != 0)
2834             time_incr++;
2835
2836         check_marker(&s->gb, "before time_increment in video packed header");
2837         time_increment= get_bits(&s->gb, s->time_increment_bits);
2838         check_marker(&s->gb, "before vop_coding_type in video packed header");
2839
2840         skip_bits(&s->gb, 2); /* vop coding type */
2841         //FIXME not rect stuff here
2842
2843         if(s->shape != BIN_ONLY_SHAPE){
2844             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2845 //FIXME dont just ignore everything
2846             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2847                 mpeg4_decode_sprite_trajectory(s);
2848                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
2849             }
2850
2851             //FIXME reduced res stuff here
2852
2853             if (s->pict_type != I_TYPE) {
2854                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
2855                 if(f_code==0){
2856                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
2857                 }
2858             }
2859             if (s->pict_type == B_TYPE) {
2860                 int b_code = get_bits(&s->gb, 3);
2861                 if(b_code==0){
2862                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
2863                 }
2864             }
2865         }
2866     }
2867     //FIXME new-pred stuff
2868
2869 //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));
2870
2871     return 0;
2872 }
2873
2874 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2875 {
2876     int c_wrap, c_xy, l_wrap, l_xy;
2877
2878     l_wrap= s->block_wrap[0];
2879     l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2880     c_wrap= s->block_wrap[4];
2881     c_xy= s->mb_y*c_wrap + s->mb_x;
2882
2883 #if 0
2884     /* clean DC */
2885     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2886     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2887     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2888 #endif
2889
2890     /* clean AC */
2891     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2892     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2893     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
2894
2895     /* clean MV */
2896     // we cant clear the MVs as they might be needed by a b frame
2897 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2898 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2899     s->last_mv[0][0][0]=
2900     s->last_mv[0][0][1]=
2901     s->last_mv[1][0][0]=
2902     s->last_mv[1][0][1]= 0;
2903 }
2904
2905 /**
2906  * decodes the group of blocks / video packet header.
2907  * @return <0 if no resync found
2908  */
2909 int ff_h263_resync(MpegEncContext *s){
2910     int left, ret;
2911
2912     if(s->codec_id==CODEC_ID_MPEG4){
2913         skip_bits1(&s->gb);
2914         align_get_bits(&s->gb);
2915     }
2916
2917     if(show_bits(&s->gb, 16)==0){
2918         if(s->codec_id==CODEC_ID_MPEG4)
2919             ret= mpeg4_decode_video_packet_header(s);
2920         else
2921             ret= h263_decode_gob_header(s);
2922         if(ret>=0)
2923             return 0;
2924     }
2925     //ok, its not where its supposed to be ...
2926     s->gb= s->last_resync_gb;
2927     align_get_bits(&s->gb);
2928     left= s->gb.size_in_bits - get_bits_count(&s->gb);
2929
2930     for(;left>16+1+5+5; left-=8){
2931         if(show_bits(&s->gb, 16)==0){
2932             GetBitContext bak= s->gb;
2933
2934             if(s->codec_id==CODEC_ID_MPEG4)
2935                 ret= mpeg4_decode_video_packet_header(s);
2936             else
2937                 ret= h263_decode_gob_header(s);
2938             if(ret>=0)
2939                 return 0;
2940
2941             s->gb= bak;
2942         }
2943         skip_bits(&s->gb, 8);
2944     }
2945
2946     return -1;
2947 }
2948
2949 /**
2950  * gets the average motion vector for a GMC MB.
2951  * @param n either 0 for the x component or 1 for y
2952  * @returns the average MV for a GMC MB
2953  */
2954 static inline int get_amv(MpegEncContext *s, int n){
2955     int x, y, mb_v, sum, dx, dy, shift;
2956     int len = 1 << (s->f_code + 4);
2957     const int a= s->sprite_warping_accuracy;
2958
2959     if(s->real_sprite_warping_points==1){
2960         if(s->divx_version==500 && s->divx_build==413)
2961             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2962         else
2963             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2964     }else{
2965         dx= s->sprite_delta[n][0];
2966         dy= s->sprite_delta[n][1];
2967         shift= s->sprite_shift[0];
2968         if(n) dy -= 1<<(shift + a + 1);
2969         else  dx -= 1<<(shift + a + 1);
2970         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2971
2972         sum=0;
2973         for(y=0; y<16; y++){
2974             int v;
2975
2976             v= mb_v + dy*y;
2977             //XXX FIXME optimize
2978             for(x=0; x<16; x++){
2979                 sum+= v>>shift;
2980                 v+= dx;
2981             }
2982         }
2983         sum= RSHIFT(sum, a+8-s->quarter_sample);
2984     }
2985
2986     if      (sum < -len) sum= -len;
2987     else if (sum >= len) sum= len-1;
2988
2989     return sum;
2990 }
2991
2992 /**
2993  * decodes first partition.
2994  * @return number of MBs decoded or <0 if an error occured
2995  */
2996 static int mpeg4_decode_partition_a(MpegEncContext *s){
2997     int mb_num;
2998     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2999
3000     /* decode first partition */
3001     mb_num=0;
3002     s->first_slice_line=1;
3003     for(; s->mb_y<s->mb_height; s->mb_y++){
3004         ff_init_block_index(s);
3005         for(; s->mb_x<s->mb_width; s->mb_x++){
3006             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3007             int cbpc;
3008             int dir=0;
3009
3010             mb_num++;
3011             ff_update_block_index(s);
3012             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3013                 s->first_slice_line=0;
3014
3015             if(s->pict_type==I_TYPE){
3016                 int i;
3017
3018                 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3019                     return mb_num-1;
3020                 }
3021
3022                 do{
3023                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3024                     if (cbpc < 0){
3025                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3026                         return -1;
3027                     }
3028                 }while(cbpc == 8);
3029
3030                 s->cbp_table[xy]= cbpc & 3;
3031                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3032                 s->mb_intra = 1;
3033
3034                 if(cbpc & 4) {
3035                     change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3036                 }
3037                 s->current_picture.qscale_table[xy]= s->qscale;
3038
3039                 s->mbintra_table[xy]= 1;
3040                 for(i=0; i<6; i++){
3041                     int dc_pred_dir;
3042                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3043                     if(dc < 0){
3044                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3045                         return -1;
3046                     }
3047                     dir<<=1;
3048                     if(dc_pred_dir) dir|=1;
3049                 }
3050                 s->pred_dir_table[xy]= dir;
3051             }else{ /* P/S_TYPE */
3052                 int mx, my, pred_x, pred_y, bits;
3053                 int16_t * const mot_val= s->motion_val[s->block_index[0]];
3054                 const int stride= s->block_wrap[0]*2;
3055
3056 //              do{ //FIXME
3057                 bits= show_bits(&s->gb, 17);
3058                 if(bits==MOTION_MARKER){
3059                     return mb_num-1;
3060                 }
3061                 skip_bits1(&s->gb);
3062                 if(bits&0x10000){
3063                     /* skip mb */
3064                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3065                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3066                         mx= get_amv(s, 0);
3067                         my= get_amv(s, 1);
3068                     }else{
3069                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3070                         mx=my=0;
3071                     }
3072                     mot_val[0       ]= mot_val[2       ]=
3073                     mot_val[0+stride]= mot_val[2+stride]= mx;
3074                     mot_val[1       ]= mot_val[3       ]=
3075                     mot_val[1+stride]= mot_val[3+stride]= my;
3076
3077                     if(s->mbintra_table[xy])
3078                         ff_clean_intra_table_entries(s);
3079                     continue;
3080                 }
3081
3082                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3083                 if (cbpc < 0){
3084                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3085                     return -1;
3086                 }
3087 //              }while(cbpc == 20);
3088
3089                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3090
3091                 s->mb_intra = ((cbpc & 4) != 0);
3092
3093                 if(s->mb_intra){
3094                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3095                     s->mbintra_table[xy]= 1;
3096                     mot_val[0       ]= mot_val[2       ]=
3097                     mot_val[0+stride]= mot_val[2+stride]= 0;
3098                     mot_val[1       ]= mot_val[3       ]=
3099                     mot_val[1+stride]= mot_val[3+stride]= 0;
3100                 }else{
3101                     if(s->mbintra_table[xy])
3102                         ff_clean_intra_table_entries(s);
3103
3104                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3105                         s->mcsel= get_bits1(&s->gb);
3106                     else s->mcsel= 0;
3107
3108                     if ((cbpc & 16) == 0) {
3109                         /* 16x16 motion prediction */
3110
3111                         h263_pred_motion(s, 0, &pred_x, &pred_y);
3112                         if(!s->mcsel){
3113                             mx = h263_decode_motion(s, pred_x, s->f_code);
3114                             if (mx >= 0xffff)
3115                                 return -1;
3116
3117                             my = h263_decode_motion(s, pred_y, s->f_code);
3118                             if (my >= 0xffff)
3119                                 return -1;
3120                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3121                         } else {
3122                             mx = get_amv(s, 0);
3123                             my = get_amv(s, 1);
3124                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3125                         }
3126
3127                         mot_val[0       ]= mot_val[2       ] =
3128                         mot_val[0+stride]= mot_val[2+stride]= mx;
3129                         mot_val[1       ]= mot_val[3       ]=
3130                         mot_val[1+stride]= mot_val[3+stride]= my;
3131                     } else {
3132                         int i;
3133                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3134                         for(i=0;i<4;i++) {
3135                             int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3136                             mx = h263_decode_motion(s, pred_x, s->f_code);
3137                             if (mx >= 0xffff)
3138                                 return -1;
3139
3140                             my = h263_decode_motion(s, pred_y, s->f_code);
3141                             if (my >= 0xffff)
3142                                 return -1;
3143                             mot_val[0] = mx;
3144                             mot_val[1] = my;
3145                         }
3146                     }
3147                 }
3148             }
3149         }
3150         s->mb_x= 0;
3151     }
3152
3153     return mb_num;
3154 }
3155
3156 /**
3157  * decode second partition.
3158  * @return <0 if an error occured
3159  */
3160 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3161     int mb_num=0;
3162     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3163
3164     s->mb_x= s->resync_mb_x;
3165     s->first_slice_line=1;
3166     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3167         ff_init_block_index(s);
3168         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3169             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3170
3171             mb_num++;
3172             ff_update_block_index(s);
3173             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3174                 s->first_slice_line=0;
3175
3176             if(s->pict_type==I_TYPE){
3177                 int ac_pred= get_bits1(&s->gb);
3178                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3179                 if(cbpy<0){
3180                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3181                     return -1;
3182                 }
3183
3184                 s->cbp_table[xy]|= cbpy<<2;
3185                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3186             }else{ /* P || S_TYPE */
3187                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3188                     int dir=0,i;
3189                     int ac_pred = get_bits1(&s->gb);
3190                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3191
3192                     if(cbpy<0){
3193                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3194                         return -1;
3195                     }
3196
3197                     if(s->cbp_table[xy] & 8) {
3198                         change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3199                     }
3200                     s->current_picture.qscale_table[xy]= s->qscale;
3201
3202                     for(i=0; i<6; i++){
3203                         int dc_pred_dir;
3204                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3205                         if(dc < 0){
3206                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3207                             return -1;
3208                         }
3209                         dir<<=1;
3210                         if(dc_pred_dir) dir|=1;
3211                     }
3212                     s->cbp_table[xy]&= 3; //remove dquant
3213                     s->cbp_table[xy]|= cbpy<<2;
3214                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3215                     s->pred_dir_table[xy]= dir;
3216                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3217                     s->current_picture.qscale_table[xy]= s->qscale;
3218                     s->cbp_table[xy]= 0;
3219                 }else{
3220                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3221
3222                     if(cbpy<0){
3223                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3224                         return -1;
3225                     }
3226
3227                     if(s->cbp_table[xy] & 8) {
3228                         change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3229                     }
3230                     s->current_picture.qscale_table[xy]= s->qscale;
3231
3232                     s->cbp_table[xy]&= 3; //remove dquant
3233                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3234                 }
3235             }
3236         }
3237         if(mb_num >= mb_count) return 0;
3238         s->mb_x= 0;
3239     }
3240     return 0;
3241 }
3242
3243 /**
3244  * decodes the first & second partition
3245  * @return <0 if error (and sets error type in the error_status_table)
3246  */
3247 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3248 {
3249     int mb_num;
3250     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3251     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3252
3253     mb_num= mpeg4_decode_partition_a(s);
3254     if(mb_num<0){
3255         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3256         return -1;
3257     }
3258
3259     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3260         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3261         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3262         return -1;
3263     }
3264
3265     s->mb_num_left= mb_num;
3266
3267     if(s->pict_type==I_TYPE){
3268         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3269             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3270             return -1;
3271         }
3272     }else{
3273         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3274             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3275             return -1;
3276         }
3277     }
3278     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3279
3280     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3281         if(s->pict_type==P_TYPE)
3282             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3283         return -1;
3284     }else{
3285         if(s->pict_type==P_TYPE)
3286             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3287     }
3288
3289     return 0;
3290 }
3291
3292 /**
3293  * decode partition C of one MB.
3294  * @return <0 if an error occured
3295  */
3296 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3297 {
3298     int cbp, mb_type;
3299     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3300
3301     mb_type= s->current_picture.mb_type[xy];
3302     cbp = s->cbp_table[xy];
3303
3304     if(s->current_picture.qscale_table[xy] != s->qscale){
3305         s->qscale= s->current_picture.qscale_table[xy];
3306         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3307         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3308     }
3309
3310     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3311         int i;
3312         for(i=0; i<4; i++){
3313             s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3314             s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3315         }
3316         s->mb_intra = IS_INTRA(mb_type);
3317
3318         if (IS_SKIP(mb_type)) {
3319             /* skip mb */
3320             for(i=0;i<6;i++)
3321                 s->block_last_index[i] = -1;
3322             s->mv_dir = MV_DIR_FORWARD;
3323             s->mv_type = MV_TYPE_16X16;
3324             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3325                 s->mcsel=1;
3326                 s->mb_skiped = 0;
3327             }else{
3328                 s->mcsel=0;
3329                 s->mb_skiped = 1;
3330             }
3331         }else if(s->mb_intra){
3332             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3333         }else if(!s->mb_intra){
3334 //            s->mcsel= 0; //FIXME do we need to init that
3335
3336             s->mv_dir = MV_DIR_FORWARD;
3337             if (IS_8X8(mb_type)) {
3338                 s->mv_type = MV_TYPE_8X8;
3339             } else {
3340                 s->mv_type = MV_TYPE_16X16;
3341             }
3342         }
3343     } else { /* I-Frame */
3344         s->mb_intra = 1;
3345         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3346     }
3347
3348     if (!IS_SKIP(mb_type)) {
3349         int i;
3350         /* decode each block */
3351         for (i = 0; i < 6; i++) {
3352             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3353                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3354                 return -1;
3355             }
3356             cbp+=cbp;
3357         }
3358     }
3359
3360     /* per-MB end of slice check */
3361
3362     if(--s->mb_num_left <= 0){
3363 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3364         if(mpeg4_is_resync(s))
3365             return SLICE_END;
3366         else
3367             return SLICE_NOEND;
3368     }else{
3369         if(mpeg4_is_resync(s)){
3370             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3371             if(s->cbp_table[xy+delta])
3372                 return SLICE_END;
3373         }
3374         return SLICE_OK;
3375     }
3376 }
3377
3378 /**
3379  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3380  */
3381 static void preview_obmc(MpegEncContext *s){
3382     GetBitContext gb= s->gb;
3383
3384     int cbpc, i, pred_x, pred_y, mx, my;
3385     int16_t *mot_val;
3386     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3387     const int stride= s->block_wrap[0]*2;
3388
3389     for(i=0; i<4; i++)
3390         s->block_index[i]+= 2;
3391     for(i=4; i<6; i++)
3392         s->block_index[i]+= 1;
3393     s->mb_x++;
3394
3395     assert(s->pict_type == P_TYPE);
3396
3397     do{
3398         if (get_bits1(&s->gb)) {
3399             /* skip mb */
3400             mot_val = s->motion_val[ s->block_index[0] ];
3401             mot_val[0       ]= mot_val[2       ]=
3402             mot_val[0+stride]= mot_val[2+stride]= 0;
3403             mot_val[1       ]= mot_val[3       ]=
3404             mot_val[1+stride]= mot_val[3+stride]= 0;
3405
3406             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3407             goto end;
3408         }
3409         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3410     }while(cbpc == 20);
3411
3412     if(cbpc & 4){
3413         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3414     }else{
3415         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3416         if (cbpc & 8) {
3417             skip_bits(&s->gb, 2);
3418         }
3419
3420         if ((cbpc & 16) == 0) {
3421                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3422                 /* 16x16 motion prediction */
3423                 mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);
3424                 if (s->umvplus)
3425                    mx = h263p_decode_umotion(s, pred_x);
3426                 else
3427                    mx = h263_decode_motion(s, pred_x, s->f_code);
3428
3429                 if (s->umvplus)
3430                    my = h263p_decode_umotion(s, pred_y);
3431                 else
3432                    my = h263_decode_motion(s, pred_y, s->f_code);
3433
3434                 mot_val[0       ]= mot_val[2       ]=
3435                 mot_val[0+stride]= mot_val[2+stride]= mx;
3436                 mot_val[1       ]= mot_val[3       ]=
3437                 mot_val[1+stride]= mot_val[3+stride]= my;
3438         } else {
3439             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3440             for(i=0;i<4;i++) {
3441                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3442                 if (s->umvplus)
3443                   mx = h263p_decode_umotion(s, pred_x);
3444                 else
3445                   mx = h263_decode_motion(s, pred_x, s->f_code);
3446
3447                 if (s->umvplus)
3448                   my = h263p_decode_umotion(s, pred_y);
3449                 else
3450                   my = h263_decode_motion(s, pred_y, s->f_code);
3451                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3452                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3453                 mot_val[0] = mx;
3454                 mot_val[1] = my;
3455             }
3456         }
3457     }
3458 end:
3459
3460     for(i=0; i<4; i++)
3461         s->block_index[i]-= 2;
3462     for(i=4; i<6; i++)
3463         s->block_index[i]-= 1;
3464     s->mb_x--;
3465
3466     s->gb= gb;
3467 }
3468
3469 int ff_h263_decode_mb(MpegEncContext *s,
3470                       DCTELEM block[6][64])
3471 {
3472     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3473     int16_t *mot_val;
3474     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3475     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3476
3477     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3478       do{
3479         if (get_bits1(&s->gb)) {
3480             /* skip mb */
3481             s->mb_intra = 0;
3482             for(i=0;i<6;i++)
3483                 s->block_last_index[i] = -1;
3484             s->mv_dir = MV_DIR_FORWARD;
3485             s->mv_type = MV_TYPE_16X16;
3486             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3487                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3488                 s->mcsel=1;
3489                 s->mv[0][0][0]= get_amv(s, 0);
3490                 s->mv[0][0][1]= get_amv(s, 1);
3491
3492                 s->mb_skiped = 0;
3493             }else{
3494                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3495                 s->mcsel=0;
3496                 s->mv[0][0][0] = 0;
3497                 s->mv[0][0][1] = 0;
3498                 s->mb_skiped = !s->obmc;
3499             }
3500             goto end;
3501         }
3502         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3503         //fprintf(stderr, "\tCBPC: %d", cbpc);
3504         if (cbpc < 0){
3505             av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3506             return -1;
3507         }
3508       }while(cbpc == 20);
3509
3510         dquant = cbpc & 8;
3511         s->mb_intra = ((cbpc & 4) != 0);
3512         if (s->mb_intra) goto intra;
3513
3514         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3515             s->mcsel= get_bits1(&s->gb);
3516         else s->mcsel= 0;
3517         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3518
3519         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3520             cbpy ^= 0xF;
3521
3522         cbp = (cbpc & 3) | (cbpy << 2);
3523         if (dquant) {
3524             if(s->modified_quant){
3525                 if(get_bits1(&s->gb))
3526                     s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3527                 else
3528                     s->qscale= get_bits(&s->gb, 5);
3529             }else
3530                 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3531             change_qscale(s, 0);
3532         }
3533         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3534             s->interlaced_dct= get_bits1(&s->gb);
3535
3536         s->mv_dir = MV_DIR_FORWARD;
3537         if ((cbpc & 16) == 0) {
3538             if(s->mcsel){
3539                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3540                 /* 16x16 global motion prediction */
3541                 s->mv_type = MV_TYPE_16X16;
3542                 mx= get_amv(s, 0);
3543                 my= get_amv(s, 1);
3544                 s->mv[0][0][0] = mx;
3545                 s->mv[0][0][1] = my;
3546             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3547                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
3548                 /* 16x8 field motion prediction */
3549                 s->mv_type= MV_TYPE_FIELD;
3550
3551                 s->field_select[0][0]= get_bits1(&s->gb);
3552                 s->field_select[0][1]= get_bits1(&s->gb);
3553
3554                 h263_pred_motion(s, 0, &pred_x, &pred_y);
3555
3556                 for(i=0; i<2; i++){
3557                     mx = h263_decode_motion(s, pred_x, s->f_code);
3558                     if (mx >= 0xffff)
3559                         return -1;
3560
3561                     my = h263_decode_motion(s, pred_y/2, s->f_code);
3562                     if (my >= 0xffff)
3563                         return -1;
3564
3565                     s->mv[0][i][0] = mx;
3566                     s->mv[0][i][1] = my;
3567                 }
3568             }else{
3569                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3570                 /* 16x16 motion prediction */
3571                 s->mv_type = MV_TYPE_16X16;
3572                 h263_pred_motion(s, 0, &pred_x, &pred_y);
3573                 if (s->umvplus)
3574                    mx = h263p_decode_umotion(s, pred_x);
3575                 else
3576                    mx = h263_decode_motion(s, pred_x, s->f_code);
3577
3578                 if (mx >= 0xffff)
3579                     return -1;
3580
3581                 if (s->umvplus)
3582                    my = h263p_decode_umotion(s, pred_y);
3583                 else
3584                    my = h263_decode_motion(s, pred_y, s->f_code);
3585
3586                 if (my >= 0xffff)
3587                     return -1;
3588                 s->mv[0][0][0] = mx;
3589                 s->mv[0][0][1] = my;
3590
3591                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3592                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3593             }
3594         } else {
3595             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3596             s->mv_type = MV_TYPE_8X8;
3597             for(i=0;i<4;i++) {
3598                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3599                 if (s->umvplus)
3600                   mx = h263p_decode_umotion(s, pred_x);
3601                 else
3602                   mx = h263_decode_motion(s, pred_x, s->f_code);
3603                 if (mx >= 0xffff)
3604                     return -1;
3605
3606                 if (s->umvplus)
3607                   my = h263p_decode_umotion(s, pred_y);
3608                 else
3609                   my = h263_decode_motion(s, pred_y, s->f_code);
3610                 if (my >= 0xffff)
3611                     return -1;
3612                 s->mv[0][i][0] = mx;
3613                 s->mv[0][i][1] = my;
3614                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3615                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3616                 mot_val[0] = mx;
3617                 mot_val[1] = my;
3618             }
3619         }
3620     } else if(s->pict_type==B_TYPE) {
3621         int modb1; // first bit of modb
3622         int modb2; // second bit of modb
3623         int mb_type;
3624
3625         s->mb_intra = 0; //B-frames never contain intra blocks
3626         s->mcsel=0;      //     ...               true gmc blocks
3627
3628         if(s->mb_x==0){
3629             for(i=0; i<2; i++){
3630                 s->last_mv[i][0][0]=
3631                 s->last_mv[i][0][1]=
3632                 s->last_mv[i][1][0]=
3633                 s->last_mv[i][1][1]= 0;
3634             }
3635         }
3636
3637         /* if we skipped it in the future P Frame than skip it now too */
3638         s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
3639
3640         if(s->mb_skiped){
3641                 /* skip mb */
3642             for(i=0;i<6;i++)
3643                 s->block_last_index[i] = -1;
3644
3645             s->mv_dir = MV_DIR_FORWARD;
3646             s->mv_type = MV_TYPE_16X16;
3647             s->mv[0][0][0] = 0;
3648             s->mv[0][0][1] = 0;
3649             s->mv[1][0][0] = 0;
3650             s->mv[1][0][1] = 0;
3651             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3652             goto end;
3653         }
3654
3655         modb1= get_bits1(&s->gb);
3656         if(modb1){
3657             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3658             cbp=0;
3659         }else{
3660             modb2= get_bits1(&s->gb);
3661             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3662             if(mb_type<0){
3663                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
3664                 return -1;
3665             }
3666             mb_type= mb_type_b_map[ mb_type ];
3667             if(modb2) cbp= 0;
3668             else      cbp= get_bits(&s->gb, 6);
3669
3670             if ((!IS_DIRECT(mb_type)) && cbp) {
3671                 if(get_bits1(&s->gb)){
3672                     change_qscale(s, get_bits1(&s->gb)*4 - 2);
3673                 }
3674             }
3675
3676             if(!s->progressive_sequence){
3677                 if(cbp)
3678                     s->interlaced_dct= get_bits1(&s->gb);
3679
3680                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3681                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3682                     mb_type &= ~MB_TYPE_16x16;
3683
3684                     if(USES_LIST(mb_type, 0)){
3685                         s->field_select[0][0]= get_bits1(&s->gb);
3686                         s->field_select[0][1]= get_bits1(&s->gb);
3687                     }
3688                     if(USES_LIST(mb_type, 1)){
3689                         s->field_select[1][0]= get_bits1(&s->gb);
3690                         s->field_select[1][1]= get_bits1(&s->gb);
3691                     }
3692                 }
3693             }
3694
3695             s->mv_dir = 0;
3696             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3697                 s->mv_type= MV_TYPE_16X16;
3698
3699                 if(USES_LIST(mb_type, 0)){
3700                     s->mv_dir = MV_DIR_FORWARD;
3701
3702                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3703                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3704                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3705                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3706                 }
3707
3708                 if(USES_LIST(mb_type, 1)){
3709                     s->mv_dir |= MV_DIR_BACKWARD;
3710
3711                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3712                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3713                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3714                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3715                 }
3716             }else if(!IS_DIRECT(mb_type)){
3717                 s->mv_type= MV_TYPE_FIELD;
3718
3719                 if(USES_LIST(mb_type, 0)){
3720                     s->mv_dir = MV_DIR_FORWARD;
3721
3722                     for(i=0; i<2; i++){
3723                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
3724                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3725                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
3726                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3727                     }
3728                 }
3729
3730                 if(USES_LIST(mb_type, 1)){
3731                     s->mv_dir |= MV_DIR_BACKWARD;
3732
3733                     for(i=0; i<2; i++){
3734                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
3735                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3736                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
3737                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3738                     }
3739                 }
3740             }
3741         }
3742
3743         if(IS_DIRECT(mb_type)){
3744             if(IS_SKIP(mb_type))
3745                 mx=my=0;
3746             else{
3747                 mx = h263_decode_motion(s, 0, 1);
3748                 my = h263_decode_motion(s, 0, 1);
3749             }
3750
3751             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3752             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3753         }
3754         s->current_picture.mb_type[xy]= mb_type;
3755     } else { /* I-Frame */
3756         do{
3757             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3758             if (cbpc < 0){
3759                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3760                 return -1;
3761             }
3762         }while(cbpc == 8);
3763
3764         dquant = cbpc & 4;
3765         s->mb_intra = 1;
3766 intra:
3767         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3768         if (s->h263_pred || s->h263_aic) {
3769             s->ac_pred = get_bits1(&s->gb);
3770             if(s->ac_pred){
3771                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3772
3773                 if (s->h263_aic)
3774                     s->h263_aic_dir = get_bits1(&s->gb);
3775             }
3776         }else
3777             s->ac_pred = 0;
3778
3779         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3780         if(cbpy<0){
3781             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3782             return -1;
3783         }
3784         cbp = (cbpc & 3) | (cbpy << 2);
3785         if (dquant) {
3786             if(s->modified_quant){
3787                 if(get_bits1(&s->gb))
3788                     s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3789                 else
3790                     s->qscale= get_bits(&s->gb, 5);
3791             }else
3792                 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3793             change_qscale(s, 0);
3794         }
3795
3796         if(!s->progressive_sequence)
3797             s->interlaced_dct= get_bits1(&s->gb);
3798
3799         /* decode each block */
3800         if (s->h263_pred) {
3801             for (i = 0; i < 6; i++) {
3802                 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3803                     return -1;
3804                 cbp+=cbp;
3805             }
3806         } else {
3807             for (i = 0; i < 6; i++) {
3808                 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3809                     return -1;
3810                 cbp+=cbp;
3811             }
3812         }
3813         goto end;
3814     }
3815
3816     /* decode each block */
3817     if (s->h263_pred) {
3818         for (i = 0; i < 6; i++) {
3819             if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3820                 return -1;
3821             cbp+=cbp;
3822         }
3823     } else {
3824         for (i = 0; i < 6; i++) {
3825             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3826                 return -1;
3827             cbp+=cbp;
3828         }
3829     }
3830 end:
3831     if(s->obmc){
3832         if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width)
3833             preview_obmc(s);
3834     }
3835
3836         /* per-MB end of slice check */
3837     if(s->codec_id==CODEC_ID_MPEG4){
3838         if(mpeg4_is_resync(s)){
3839             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3840             if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3841                 return SLICE_OK;
3842             return SLICE_END;
3843         }
3844     }else{
3845         int v= show_bits(&s->gb, 16);
3846
3847         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3848             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3849         }
3850
3851         if(v==0)
3852             return SLICE_END;
3853     }
3854
3855     return SLICE_OK;
3856 }
3857
3858 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3859 {
3860     int code, val, sign, shift, l;
3861     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3862
3863     if (code == 0)
3864         return pred;
3865     if (code < 0)
3866         return 0xffff;
3867
3868     sign = get_bits1(&s->gb);
3869     shift = f_code - 1;
3870     val = code;
3871     if (shift) {
3872         val = (val - 1) << shift;
3873         val |= get_bits(&s->gb, shift);
3874         val++;
3875     }
3876     if (sign)
3877         val = -val;
3878     val += pred;
3879
3880     /* modulo decoding */
3881     if (!s->h263_long_vectors) {
3882         l = 1 << (f_code + 4);
3883         val = ((val + l)&(l*2-1)) - l;
3884     } else {
3885         /* horrible h263 long vector mode */
3886         if (pred < -31 && val < -63)
3887             val += 64;
3888         if (pred > 32 && val > 63)
3889             val -= 64;
3890
3891     }
3892     return val;
3893 }
3894
3895 /* Decodes RVLC of H.263+ UMV */
3896 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3897 {
3898    int code = 0, sign;
3899
3900    if (get_bits1(&s->gb)) /* Motion difference = 0 */
3901       return pred;
3902
3903    code = 2 + get_bits1(&s->gb);
3904
3905    while (get_bits1(&s->gb))
3906    {
3907       code <<= 1;
3908       code += get_bits1(&s->gb);
3909    }
3910    sign = code & 1;
3911    code >>= 1;
3912
3913    code = (sign) ? (pred - code) : (pred + code);
3914 #ifdef DEBUG
3915    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3916 #endif
3917    return code;
3918
3919 }
3920
3921 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3922                              int n, int coded)
3923 {
3924     int code, level, i, j, last, run;
3925     RLTable *rl = &rl_inter;
3926     const uint8_t *scan_table;
3927     GetBitContext gb= s->gb;
3928
3929     scan_table = s->intra_scantable.permutated;
3930     if (s->h263_aic && s->mb_intra) {
3931         rl = &rl_intra_aic;
3932         i = 0;
3933         if (s->ac_pred) {
3934             if (s->h263_aic_dir)
3935                 scan_table = s->intra_v_scantable.permutated; /* left */
3936             else
3937                 scan_table = s->intra_h_scantable.permutated; /* top */
3938         }
3939     } else if (s->mb_intra) {
3940         /* DC coef */
3941         if(s->h263_rv10){
3942           if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3943             int component, diff;
3944             component = (n <= 3 ? 0 : n - 4 + 1);
3945             level = s->last_dc[component];
3946             if (s->rv10_first_dc_coded[component]) {
3947                 diff = rv_decode_dc(s, n);
3948                 if (diff == 0xffff)
3949                     return -1;
3950                 level += diff;
3951                 level = level & 0xff; /* handle wrap round */
3952                 s->last_dc[component] = level;
3953             } else {
3954                 s->rv10_first_dc_coded[component] = 1;
3955             }
3956           } else {
3957                 level = get_bits(&s->gb, 8);
3958           }
3959         }else{
3960             level = get_bits(&s->gb, 8);
3961             if((level&0x7F) == 0){
3962                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3963                 return -1;
3964             }
3965             if (level == 255)
3966                 level = 128;
3967         }
3968         block[0] = level;
3969         i = 1;
3970     } else {
3971         i = 0;
3972     }
3973     if (!coded) {
3974         if (s->mb_intra && s->h263_aic)
3975             goto not_coded;
3976         s->block_last_index[n] = i - 1;
3977         return 0;
3978     }
3979 retry:
3980     for(;;) {
3981         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3982         if (code < 0){
3983             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3984             return -1;
3985         }
3986         if (code == rl->n) {
3987             /* escape */
3988             if (s->h263_flv > 1) {
3989                 int is11 = get_bits1(&s->gb);
3990                 last = get_bits1(&s->gb);
3991                 run = get_bits(&s->gb, 6);
3992                 if(is11){
3993                     level = get_sbits(&s->gb, 11);
3994                 } else {
3995                     level = get_sbits(&s->gb, 7);
3996                 }
3997             } else {
3998                 last = get_bits1(&s->gb);
3999                 run = get_bits(&s->gb, 6);
4000                 level = (int8_t)get_bits(&s->gb, 8);
4001                 if(level == -128){
4002                     if (s->h263_rv10) {
4003                         /* XXX: should patch encoder too */
4004                         level = get_sbits(&s->gb, 12);
4005                     }else{
4006                         level = get_bits(&s->gb, 5);
4007                         level |= get_sbits(&s->gb, 6)<<5;
4008                     }
4009                 }
4010             }
4011         } else {
4012             run = rl->table_run[code];
4013             level = rl->table_level[code];
4014             last = code >= rl->last;
4015             if (get_bits1(&s->gb))
4016                 level = -level;
4017         }
4018         i += run;
4019         if (i >= 64){
4020             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4021                 //looks like a hack but no, its the way its supposed to work ...
4022                 rl = &rl_intra_aic;
4023                 i = 0;
4024                 s->gb= gb;
4025                 memset(block, 0, sizeof(DCTELEM)*64);
4026                 goto retry;
4027             }
4028             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4029             return -1;
4030         }
4031         j = scan_table[i];
4032         block[j] = level;
4033         if (last)
4034             break;
4035         i++;
4036     }
4037 not_coded:
4038     if (s->mb_intra && s->h263_aic) {
4039         h263_pred_acdc(s, block, n);
4040         i = 63;
4041     }
4042     s->block_last_index[n] = i;
4043     return 0;
4044 }
4045
4046 /**
4047  * decodes the dc value.
4048  * @param n block index (0-3 are luma, 4-5 are chroma)
4049  * @param dir_ptr the prediction direction will be stored here
4050  * @return the quantized dc
4051  */
4052 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4053 {
4054     int level, pred, code;
4055     uint16_t *dc_val;
4056
4057     if (n < 4)
4058         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4059     else
4060         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4061     if (code < 0 || code > 9 /* && s->nbit<9 */){
4062         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4063         return -1;
4064     }
4065     if (code == 0) {
4066         level = 0;
4067     } else {
4068         if(IS_3IV1){
4069             if(code==1)
4070                 level= 2*get_bits1(&s->gb)-1;
4071             else{
4072                 if(get_bits1(&s->gb))
4073                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
4074                 else
4075                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4076             }
4077         }else{
4078             level = get_xbits(&s->gb, code);
4079         }
4080
4081         if (code > 8){
4082             if(get_bits1(&s->gb)==0){ /* marker */
4083                 if(s->error_resilience>=2){
4084                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4085                     return -1;
4086                 }
4087             }
4088         }
4089     }
4090     pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4091     level += pred;
4092     if (level < 0){
4093         if(s->error_resilience>=3){
4094             av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4095             return -1;
4096         }
4097         level = 0;
4098     }
4099     if (n < 4) {
4100         *dc_val = level * s->y_dc_scale;
4101     } else {
4102         *dc_val = level * s->c_dc_scale;
4103     }
4104     if(IS_3IV1)
4105         *dc_val = level * 8;
4106
4107     if(s->error_resilience>=3){
4108         if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4109             av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4110             return -1;
4111         }
4112     }
4113     return level;
4114 }
4115
4116 /**
4117  * decodes a block.
4118  * @return <0 if an error occured
4119  */
4120 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4121                               int n, int coded, int intra, int rvlc)
4122 {
4123     int level, i, last, run;
4124     int dc_pred_dir;
4125     RLTable * rl;
4126     RL_VLC_ELEM * rl_vlc;
4127     const uint8_t * scan_table;
4128     int qmul, qadd;
4129
4130     //Note intra & rvlc should be optimized away if this is inlined
4131
4132     if(intra) {
4133       if(s->qscale < s->intra_dc_threshold){
4134         /* DC coef */
4135         if(s->partitioned_frame){
4136             level = s->dc_val[0][ s->block_index[n] ];
4137             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4138             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4139             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4140         }else{
4141             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4142             if (level < 0)
4143                 return -1;
4144         }
4145         block[0] = level;
4146         i = 0;
4147       }else{
4148             i = -1;
4149       }
4150         if (!coded)
4151             goto not_coded;
4152
4153         if(rvlc){
4154             rl = &rvlc_rl_intra;
4155             rl_vlc = rvlc_rl_intra.rl_vlc[0];
4156         }else{
4157             rl = &rl_intra;
4158             rl_vlc = rl_intra.rl_vlc[0];
4159         }
4160         if (s->ac_pred) {
4161             if (dc_pred_dir == 0)
4162                 scan_table = s->intra_v_scantable.permutated; /* left */
4163             else
4164                 scan_table = s->intra_h_scantable.permutated; /* top */
4165         } else {
4166             scan_table = s->intra_scantable.permutated;
4167         }
4168         qmul=1;
4169         qadd=0;
4170     } else {
4171         i = -1;
4172         if (!coded) {
4173             s->block_last_index[n] = i;
4174             return 0;
4175         }
4176         if(rvlc) rl = &rvlc_rl_inter;
4177         else     rl = &rl_inter;
4178
4179         scan_table = s->intra_scantable.permutated;
4180
4181         if(s->mpeg_quant){
4182             qmul=1;
4183             qadd=0;
4184             if(rvlc){
4185                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4186             }else{
4187                 rl_vlc = rl_inter.rl_vlc[0];
4188             }
4189         }else{
4190             qmul = s->qscale << 1;
4191             qadd = (s->qscale - 1) | 1;
4192             if(rvlc){
4193                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4194             }else{
4195                 rl_vlc = rl_inter.rl_vlc[s->qscale];
4196             }
4197         }
4198     }
4199   {
4200     OPEN_READER(re, &s->gb);
4201     for(;;) {
4202         UPDATE_CACHE(re, &s->gb);
4203         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4204         if (level==0) {
4205           /* escape */
4206           if(rvlc){
4207                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4208                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4209                     return -1;
4210                 }; SKIP_CACHE(re, &s->gb, 1);
4211
4212                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4213                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4214                 SKIP_COUNTER(re, &s->gb, 1+1+6);
4215                 UPDATE_CACHE(re, &s->gb);
4216
4217                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4218                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4219                     return -1;
4220                 }; SKIP_CACHE(re, &s->gb, 1);
4221
4222                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4223
4224                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4225                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4226                     return -1;
4227                 }; SKIP_CACHE(re, &s->gb, 5);
4228
4229                 level=  level * qmul + qadd;
4230                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4231                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4232
4233                 i+= run + 1;
4234                 if(last) i+=192;
4235           }else{
4236             int cache;
4237             cache= GET_CACHE(re, &s->gb);
4238
4239             if(IS_3IV1)
4240                 cache ^= 0xC0000000;
4241
4242             if (cache&0x80000000) {
4243                 if (cache&0x40000000) {
4244                     /* third escape */
4245                     SKIP_CACHE(re, &s->gb, 2);
4246                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4247                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4248                     SKIP_COUNTER(re, &s->gb, 2+1+6);
4249                     UPDATE_CACHE(re, &s->gb);
4250
4251                     if(IS_3IV1){
4252                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4253                     }else{
4254                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4255                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4256                             return -1;
4257                         }; SKIP_CACHE(re, &s->gb, 1);
4258
4259                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4260
4261                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4262                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4263                             return -1;
4264                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
4265
4266                         SKIP_COUNTER(re, &s->gb, 1+12+1);
4267                     }
4268
4269                     if(level*s->qscale>1024 || level*s->qscale<-1024){
4270                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4271                         return -1;
4272                     }
4273 #if 0
4274                     if(s->error_resilience >= FF_ER_COMPLIANT){
4275                         const int abs_level= ABS(level);
4276                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4277                             const int run1= run - rl->max_run[last][abs_level] - 1;
4278                             if(abs_level <= rl->max_level[last][run]){
4279                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4280                                 return -1;
4281                             }
4282                             if(s->error_resilience > FF_ER_COMPLIANT){
4283                                 if(abs_level <= rl->max_level[last][run]*2){
4284                                     fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4285                                     return -1;
4286                                 }
4287                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4288                                     fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4289                                     return -1;
4290                                 }
4291                             }
4292                         }
4293                     }
4294 #endif
4295                     if (level>0) level= level * qmul + qadd;
4296                     else         level= level * qmul - qadd;
4297
4298                     i+= run + 1;
4299                     if(last) i+=192;
4300                 } else {
4301                     /* second escape */
4302 #if MIN_CACHE_BITS < 20
4303                     LAST_SKIP_BITS(re, &s->gb, 2);
4304                     UPDATE_CACHE(re, &s->gb);
4305 #else
4306                     SKIP_BITS(re, &s->gb, 2);
4307 #endif
4308                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4309                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4310                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4311                     LAST_SKIP_BITS(re, &s->gb, 1);
4312                 }
4313             } else {
4314                 /* first escape */
4315 #if MIN_CACHE_BITS < 19
4316                 LAST_SKIP_BITS(re, &s->gb, 1);
4317                 UPDATE_CACHE(re, &s->gb);
4318 #else
4319                 SKIP_BITS(re, &s->gb, 1);
4320 #endif
4321                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4322                 i+= run;
4323                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4324                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4325                 LAST_SKIP_BITS(re, &s->gb, 1);
4326             }
4327           }
4328         } else {
4329             i+= run;
4330             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4331             LAST_SKIP_BITS(re, &s->gb, 1);
4332         }
4333         if (i > 62){
4334             i-= 192;
4335             if(i&(~63)){
4336                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4337                 return -1;
4338             }
4339
4340             block[scan_table[i]] = level;
4341             break;
4342         }
4343
4344         block[scan_table[i]] = level;
4345     }
4346     CLOSE_READER(re, &s->gb);
4347   }
4348  not_coded:
4349     if (intra) {
4350         if(s->qscale >= s->intra_dc_threshold){
4351             uint16_t *dc_val;
4352             block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir);
4353             if (n < 4) {
4354                 *dc_val = block[0] * s->y_dc_scale;
4355             } else {
4356                 *dc_val = block[0] * s->c_dc_scale;
4357             }
4358
4359             if(i == -1) i=0;
4360         }
4361
4362         mpeg4_pred_ac(s, block, n, dc_pred_dir);
4363         if (s->ac_pred) {
4364             i = 63; /* XXX: not optimal */
4365         }
4366     }
4367     s->block_last_index[n] = i;
4368     return 0;
4369 }
4370
4371 /* most is hardcoded. should extend to handle all h263 streams */
4372 int h263_decode_picture_header(MpegEncContext *s)
4373 {
4374     int format, width, height, i;
4375     uint32_t startcode;
4376
4377     align_get_bits(&s->gb);
4378
4379     startcode= get_bits(&s->gb, 22-8);
4380
4381     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4382         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4383
4384         if(startcode == 0x20)
4385             break;
4386     }
4387
4388     if (startcode != 0x20) {
4389         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
4390         return -1;
4391     }
4392     /* temporal reference */
4393     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4394
4395     /* PTYPE starts here */
4396     if (get_bits1(&s->gb) != 1) {
4397         /* marker */
4398         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
4399         return -1;
4400     }
4401     if (get_bits1(&s->gb) != 0) {
4402         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
4403         return -1;      /* h263 id */
4404     }
4405     skip_bits1(&s->gb); /* split screen off */
4406     skip_bits1(&s->gb); /* camera  off */
4407     skip_bits1(&s->gb); /* freeze picture release off */
4408
4409     /* Reset GOB number */
4410     s->gob_number = 0;
4411
4412     format = get_bits(&s->gb, 3);
4413     /*
4414         0    forbidden
4415         1    sub-QCIF
4416         10   QCIF
4417         7       extended PTYPE (PLUSPTYPE)
4418     */
4419
4420     if (format != 7 && format != 6) {
4421         s->h263_plus = 0;
4422         /* H.263v1 */
4423         width = h263_format[format][0];
4424         height = h263_format[format][1];
4425         if (!width)
4426             return -1;
4427
4428         s->pict_type = I_TYPE + get_bits1(&s->gb);
4429
4430         s->h263_long_vectors = get_bits1(&s->gb);
4431
4432         if (get_bits1(&s->gb) != 0) {
4433             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
4434             return -1;  /* SAC: off */
4435         }
4436         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4437         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
4438
4439         if (get_bits1(&s->gb) != 0) {
4440             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
4441             return -1;  /* not PB frame */
4442         }
4443         s->qscale = get_bits(&s->gb, 5);
4444         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
4445
4446         s->width = width;
4447         s->height = height;
4448     } else {
4449         int ufep;
4450
4451         /* H.263v2 */
4452         s->h263_plus = 1;
4453         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4454
4455         /* ufep other than 0 and 1 are reserved */
4456         if (ufep == 1) {
4457             /* OPPTYPE */
4458             format = get_bits(&s->gb, 3);
4459             dprintf("ufep=1, format: %d\n", format);
4460             skip_bits(&s->gb,1); /* Custom PCF */
4461             s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4462             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
4463             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4464             s->unrestricted_mv = s->umvplus || s->obmc;
4465             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
4466
4467             if (get_bits1(&s->gb) != 0) {
4468                 av_log(s->avctx, AV_LOG_ERROR, "Deblocking Filter not supported\n");
4469             }
4470             if (get_bits1(&s->gb) != 0) {
4471                 av_log(s->avctx, AV_LOG_ERROR, "Slice Structured not supported\n");
4472             }
4473             if (get_bits1(&s->gb) != 0) {
4474                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
4475             }
4476             if (get_bits1(&s->gb) != 0) {
4477                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
4478             }
4479             s->alt_inter_vlc= get_bits1(&s->gb);
4480             s->modified_quant= get_bits1(&s->gb);
4481
4482             skip_bits(&s->gb, 1); /* Prevent start code emulation */
4483
4484             skip_bits(&s->gb, 3); /* Reserved */
4485         } else if (ufep != 0) {
4486             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
4487             return -1;
4488         }
4489
4490         /* MPPTYPE */
4491         s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4492         if (s->pict_type == 8 && s->avctx->codec_tag == ff_get_fourcc("ZYGO"))
4493             s->pict_type = I_TYPE;
4494         if (s->pict_type != I_TYPE &&
4495             s->pict_type != P_TYPE)
4496             return -1;
4497         skip_bits(&s->gb, 2);
4498         s->no_rounding = get_bits1(&s->gb);
4499         skip_bits(&s->gb, 4);
4500
4501         /* Get the picture dimensions */
4502         if (ufep) {
4503             if (format == 6) {
4504                 /* Custom Picture Format (CPFMT) */
4505                 s->aspect_ratio_info = get_bits(&s->gb, 4);
4506                 dprintf("aspect: %d\n", s->aspect_ratio_info);
4507                 /* aspect ratios:
4508                 0 - forbidden
4509                 1 - 1:1
4510                 2 - 12:11 (CIF 4:3)
4511                 3 - 10:11 (525-type 4:3)
4512                 4 - 16:11 (CIF 16:9)
4513                 5 - 40:33 (525-type 16:9)
4514                 6-14 - reserved
4515                 */
4516                 width = (get_bits(&s->gb, 9) + 1) * 4;
4517                 skip_bits1(&s->gb);
4518                 height = get_bits(&s->gb, 9) * 4;
4519                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4520                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4521                     /* aspected dimensions */
4522                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
4523                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
4524                 }else{
4525                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4526                 }
4527             } else {
4528                 width = h263_format[format][0];
4529                 height = h263_format[format][1];
4530             }
4531             if ((width == 0) || (height == 0))
4532                 return -1;
4533             s->width = width;
4534             s->height = height;
4535             if (s->umvplus) {
4536                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4537                     skip_bits1(&s->gb);
4538             }
4539         }
4540
4541         s->qscale = get_bits(&s->gb, 5);
4542     }
4543     /* PEI */
4544     while (get_bits1(&s->gb) != 0) {
4545         skip_bits(&s->gb, 8);
4546     }
4547     s->f_code = 1;
4548
4549     if(s->h263_aic){
4550          s->y_dc_scale_table=
4551          s->c_dc_scale_table= ff_aic_dc_scale_table;
4552     }else{
4553         s->y_dc_scale_table=
4554         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4555     }
4556
4557      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4558          av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s\n",
4559          s->qscale, av_get_pict_type_char(s->pict_type),
4560          s->gb.size_in_bits, 1-s->no_rounding,
4561          s->obmc ? " AP" : "",
4562          s->umvplus ? " UMV" : "",
4563          s->h263_long_vectors ? " LONG" : "",
4564          s->h263_plus ? " +" : "",
4565          s->h263_aic ? " AIC" : "",
4566          s->alt_inter_vlc ? " AIV" : "",
4567          s->modified_quant ? " MQ" : ""
4568          );
4569      }
4570 #if 1
4571     if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
4572         int i,j;
4573         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
4574         av_log(s->avctx, AV_LOG_DEBUG, "\n");
4575         for(i=0; i<13; i++){
4576             for(j=0; j<3; j++){
4577                 int v= get_bits(&s->gb, 8);
4578                 v |= get_sbits(&s->gb, 8)<<8;
4579                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
4580             }
4581             av_log(s->avctx, AV_LOG_DEBUG, "\n");
4582         }
4583         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
4584     }
4585 #endif
4586
4587     return 0;
4588 }
4589
4590 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4591 {
4592     int i;
4593     int a= 2<<s->sprite_warping_accuracy;
4594     int rho= 3-s->sprite_warping_accuracy;
4595     int r=16/a;
4596     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4597     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4598     int sprite_ref[4][2];
4599     int virtual_ref[2][2];
4600     int w2, h2, w3, h3;
4601     int alpha=0, beta=0;
4602     int w= s->width;
4603     int h= s->height;
4604     int min_ab;
4605
4606     for(i=0; i<s->num_sprite_warping_points; i++){
4607         int length;
4608         int x=0, y=0;
4609
4610         length= get_vlc(&s->gb, &sprite_trajectory);
4611         if(length){
4612             x= get_xbits(&s->gb, length);
4613         }
4614         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4615
4616         length= get_vlc(&s->gb, &sprite_trajectory);
4617         if(length){
4618             y=get_xbits(&s->gb, length);
4619         }
4620         skip_bits1(&s->gb); /* marker bit */
4621 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4622         d[i][0]= x;
4623         d[i][1]= y;
4624     }
4625
4626     while((1<<alpha)<w) alpha++;
4627     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4628     w2= 1<<alpha;
4629     h2= 1<<beta;
4630
4631 // Note, the 4th point isnt used for GMC
4632     if(s->divx_version==500 && s->divx_build==413){
4633         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4634         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4635         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4636         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4637         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4638         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4639     } else {
4640         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4641         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4642         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4643         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4644         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4645         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4646     }
4647 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4648     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4649
4650 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4651 // perhaps it should be reordered to be more readable ...
4652 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4653 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4654     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
4655         + 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);
4656     virtual_ref[0][1]= 16*vop_ref[0][1]
4657         + 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);
4658     virtual_ref[1][0]= 16*vop_ref[0][0]
4659         + 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);
4660     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
4661         + 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);
4662
4663     switch(s->num_sprite_warping_points)
4664     {
4665         case 0:
4666             s->sprite_offset[0][0]= 0;
4667             s->sprite_offset[0][1]= 0;
4668             s->sprite_offset[1][0]= 0;
4669             s->sprite_offset[1][1]= 0;
4670             s->sprite_delta[0][0]= a;
4671             s->sprite_delta[0][1]= 0;
4672             s->sprite_delta[1][0]= 0;
4673             s->sprite_delta[1][1]= a;
4674             s->sprite_shift[0]= 0;
4675             s->sprite_shift[1]= 0;
4676             break;
4677         case 1: //GMC only
4678             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4679             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4680             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4681             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4682             s->sprite_delta[0][0]= a;
4683             s->sprite_delta[0][1]= 0;
4684             s->sprite_delta[1][0]= 0;
4685             s->sprite_delta[1][1]= a;
4686             s->sprite_shift[0]= 0;
4687             s->sprite_shift[1]= 0;
4688             break;
4689         case 2:
4690             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4691                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4692                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4693                                                   + (1<<(alpha+rho-1));
4694             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4695                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4696                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4697                                                   + (1<<(alpha+rho-1));
4698             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4699                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4700                                      +2*w2*r*sprite_ref[0][0]
4701                                      - 16*w2
4702                                      + (1<<(alpha+rho+1)));
4703             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
4704                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4705                                      +2*w2*r*sprite_ref[0][1]
4706                                      - 16*w2
4707                                      + (1<<(alpha+rho+1)));
4708             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4709             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4710             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4711             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4712
4713             s->sprite_shift[0]= alpha+rho;
4714             s->sprite_shift[1]= alpha+rho+2;
4715             break;
4716         case 3:
4717             min_ab= FFMIN(alpha, beta);
4718             w3= w2>>min_ab;
4719             h3= h2>>min_ab;
4720             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4721                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4722                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4723                                    + (1<<(alpha+beta+rho-min_ab-1));
4724             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4725                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4726                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4727                                    + (1<<(alpha+beta+rho-min_ab-1));
4728             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4729                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4730                                    + 2*w2*h3*r*sprite_ref[0][0]
4731                                    - 16*w2*h3
4732                                    + (1<<(alpha+beta+rho-min_ab+1));
4733             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4734                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4735                                    + 2*w2*h3*r*sprite_ref[0][1]
4736                                    - 16*w2*h3
4737                                    + (1<<(alpha+beta+rho-min_ab+1));
4738             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4739             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4740             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4741             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4742
4743             s->sprite_shift[0]= alpha + beta + rho - min_ab;
4744             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4745             break;
4746     }
4747     /* try to simplify the situation */
4748     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4749        && s->sprite_delta[0][1] == 0
4750        && s->sprite_delta[1][0] == 0
4751        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4752     {
4753         s->sprite_offset[0][0]>>=s->sprite_shift[0];
4754         s->sprite_offset[0][1]>>=s->sprite_shift[0];
4755         s->sprite_offset[1][0]>>=s->sprite_shift[1];
4756         s->sprite_offset[1][1]>>=s->sprite_shift[1];
4757         s->sprite_delta[0][0]= a;
4758         s->sprite_delta[0][1]= 0;
4759         s->sprite_delta[1][0]= 0;
4760         s->sprite_delta[1][1]= a;
4761         s->sprite_shift[0]= 0;
4762         s->sprite_shift[1]= 0;
4763         s->real_sprite_warping_points=1;
4764     }
4765     else{
4766         int shift_y= 16 - s->sprite_shift[0];
4767         int shift_c= 16 - s->sprite_shift[1];
4768 //printf("shifts %d %d\n", shift_y, shift_c);
4769         for(i=0; i<2; i++){
4770             s->sprite_offset[0][i]<<= shift_y;
4771             s->sprite_offset[1][i]<<= shift_c;
4772             s->sprite_delta[0][i]<<= shift_y;
4773             s->sprite_delta[1][i]<<= shift_y;
4774             s->sprite_shift[i]= 16;
4775         }
4776         s->real_sprite_warping_points= s->num_sprite_warping_points;
4777     }
4778 #if 0
4779 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4780     vop_ref[0][0], vop_ref[0][1],
4781     vop_ref[1][0], vop_ref[1][1],
4782     vop_ref[2][0], vop_ref[2][1],
4783     sprite_ref[0][0], sprite_ref[0][1],
4784     sprite_ref[1][0], sprite_ref[1][1],
4785     sprite_ref[2][0], sprite_ref[2][1],
4786     virtual_ref[0][0], virtual_ref[0][1],
4787     virtual_ref[1][0], virtual_ref[1][1]
4788     );
4789
4790 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4791     s->sprite_offset[0][0], s->sprite_offset[0][1],
4792     s->sprite_delta[0][0], s->sprite_delta[0][1],
4793     s->sprite_delta[1][0], s->sprite_delta[1][1],
4794     s->sprite_shift[0]
4795     );
4796 #endif
4797 }
4798
4799 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4800     int hours, minutes, seconds;
4801
4802     hours= get_bits(gb, 5);
4803     minutes= get_bits(gb, 6);
4804     skip_bits1(gb);
4805     seconds= get_bits(gb, 6);
4806
4807     s->time_base= seconds + 60*(minutes + 60*hours);
4808
4809     skip_bits1(gb);
4810     skip_bits1(gb);
4811
4812     return 0;
4813 }
4814
4815 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4816     int width, height, vo_ver_id;
4817
4818     /* vol header */
4819     skip_bits(gb, 1); /* random access */
4820     s->vo_type= get_bits(gb, 8);
4821     if (get_bits1(gb) != 0) { /* is_ol_id */
4822         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4823         skip_bits(gb, 3); /* vo_priority */
4824     } else {
4825         vo_ver_id = 1;
4826     }
4827 //printf("vo type:%d\n",s->vo_type);
4828     s->aspect_ratio_info= get_bits(gb, 4);
4829     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4830         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
4831         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
4832     }else{
4833         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4834     }
4835
4836     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4837         int chroma_format= get_bits(gb, 2);
4838         if(chroma_format!=1){
4839             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
4840         }
4841         s->low_delay= get_bits1(gb);
4842         if(get_bits1(gb)){ /* vbv parameters */
4843             get_bits(gb, 15);   /* first_half_bitrate */
4844             skip_bits1(gb);     /* marker */
4845             get_bits(gb, 15);   /* latter_half_bitrate */
4846             skip_bits1(gb);     /* marker */
4847             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
4848             skip_bits1(gb);     /* marker */
4849             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
4850             get_bits(gb, 11);   /* first_half_vbv_occupancy */
4851             skip_bits1(gb);     /* marker */
4852             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
4853             skip_bits1(gb);     /* marker */
4854         }
4855     }else{
4856         // set low delay flag only once so the smart? low delay detection wont be overriden
4857         if(s->picture_number==0)
4858             s->low_delay=0;
4859     }
4860
4861     s->shape = get_bits(gb, 2); /* vol shape */
4862     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
4863     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4864         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
4865         skip_bits(gb, 4);  //video_object_layer_shape_extension
4866     }
4867
4868     check_marker(gb, "before time_increment_resolution");
4869
4870     s->time_increment_resolution = get_bits(gb, 16);
4871
4872     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4873     if (s->time_increment_bits < 1)
4874         s->time_increment_bits = 1;
4875
4876     check_marker(gb, "before fixed_vop_rate");
4877
4878     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
4879         skip_bits(gb, s->time_increment_bits);
4880     }
4881
4882     if (s->shape != BIN_ONLY_SHAPE) {
4883         if (s->shape == RECT_SHAPE) {
4884             skip_bits1(gb);   /* marker */
4885             width = get_bits(gb, 13);
4886             skip_bits1(gb);   /* marker */
4887             height = get_bits(gb, 13);
4888             skip_bits1(gb);   /* marker */
4889             if(width && height){ /* they should be non zero but who knows ... */
4890                 s->width = width;
4891                 s->height = height;
4892 //                printf("width/height: %d %d\n", width, height);
4893             }
4894         }
4895
4896         s->progressive_sequence= get_bits1(gb)^1;
4897         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
4898             av_log(s->avctx, AV_LOG_ERROR, "OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
4899         if (vo_ver_id == 1) {
4900             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4901         } else {
4902             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4903         }
4904         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
4905         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4906             if(s->vol_sprite_usage==STATIC_SPRITE){
4907                 s->sprite_width = get_bits(gb, 13);
4908                 skip_bits1(gb); /* marker */
4909                 s->sprite_height= get_bits(gb, 13);
4910                 skip_bits1(gb); /* marker */
4911                 s->sprite_left  = get_bits(gb, 13);
4912                 skip_bits1(gb); /* marker */
4913                 s->sprite_top   = get_bits(gb, 13);
4914                 skip_bits1(gb); /* marker */
4915             }
4916             s->num_sprite_warping_points= get_bits(gb, 6);
4917             s->sprite_warping_accuracy = get_bits(gb, 2);
4918             s->sprite_brightness_change= get_bits1(gb);
4919             if(s->vol_sprite_usage==STATIC_SPRITE)
4920                 s->low_latency_sprite= get_bits1(gb);
4921         }
4922         // FIXME sadct disable bit if verid!=1 && shape not rect
4923
4924         if (get_bits1(gb) == 1) {   /* not_8_bit */
4925             s->quant_precision = get_bits(gb, 4); /* quant_precision */
4926             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
4927             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %d\n", s->quant_precision);
4928         } else {
4929             s->quant_precision = 5;
4930         }
4931
4932         // FIXME a bunch of grayscale shape things
4933
4934         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4935             int i, v;
4936
4937             /* load default matrixes */
4938             for(i=0; i<64; i++){
4939                 int j= s->dsp.idct_permutation[i];
4940                 v= ff_mpeg4_default_intra_matrix[i];
4941                 s->intra_matrix[j]= v;
4942                 s->chroma_intra_matrix[j]= v;
4943
4944                 v= ff_mpeg4_default_non_intra_matrix[i];
4945                 s->inter_matrix[j]= v;
4946                 s->chroma_inter_matrix[j]= v;
4947             }
4948
4949             /* load custom intra matrix */
4950             if(get_bits1(gb)){
4951                 int last=0;
4952                 for(i=0; i<64; i++){
4953                     int j;
4954                     v= get_bits(gb, 8);
4955                     if(v==0) break;
4956
4957                     last= v;
4958                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4959                     s->intra_matrix[j]= v;
4960                     s->chroma_intra_matrix[j]= v;
4961                 }
4962
4963                 /* replicate last value */
4964                 for(; i<64; i++){
4965                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4966                     s->intra_matrix[j]= last;
4967                     s->chroma_intra_matrix[j]= last;
4968                 }
4969             }
4970
4971             /* load custom non intra matrix */
4972             if(get_bits1(gb)){
4973                 int last=0;
4974                 for(i=0; i<64; i++){
4975                     int j;
4976                     v= get_bits(gb, 8);
4977                     if(v==0) break;
4978
4979                     last= v;
4980                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4981                     s->inter_matrix[j]= v;
4982                     s->chroma_inter_matrix[j]= v;
4983                 }
4984
4985                 /* replicate last value */
4986                 for(; i<64; i++){
4987                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4988                     s->inter_matrix[j]= last;
4989                     s->chroma_inter_matrix[j]= last;
4990                 }
4991             }
4992
4993             // FIXME a bunch of grayscale shape things
4994         }
4995
4996         if(vo_ver_id != 1)
4997              s->quarter_sample= get_bits1(gb);
4998         else s->quarter_sample=0;
4999
5000         if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5001
5002         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5003
5004         s->data_partitioning= get_bits1(gb);
5005         if(s->data_partitioning){
5006             s->rvlc= get_bits1(gb);
5007         }
5008
5009         if(vo_ver_id != 1) {
5010             s->new_pred= get_bits1(gb);
5011             if(s->new_pred){
5012                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5013                 skip_bits(gb, 2); /* requested upstream message type */
5014                 skip_bits1(gb); /* newpred segment type */
5015             }
5016             s->reduced_res_vop= get_bits1(gb);
5017             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5018         }
5019         else{
5020             s->new_pred=0;
5021             s->reduced_res_vop= 0;
5022         }
5023
5024         s->scalability= get_bits1(gb);
5025
5026         if (s->scalability) {
5027             GetBitContext bak= *gb;
5028             int ref_layer_id;
5029             int ref_layer_sampling_dir;
5030             int h_sampling_factor_n;
5031             int h_sampling_factor_m;
5032             int v_sampling_factor_n;
5033             int v_sampling_factor_m;
5034
5035             s->hierachy_type= get_bits1(gb);
5036             ref_layer_id= get_bits(gb, 4);
5037             ref_layer_sampling_dir= get_bits1(gb);
5038             h_sampling_factor_n= get_bits(gb, 5);
5039             h_sampling_factor_m= get_bits(gb, 5);
5040             v_sampling_factor_n= get_bits(gb, 5);
5041             v_sampling_factor_m= get_bits(gb, 5);
5042             s->enhancement_type= get_bits1(gb);
5043
5044             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
5045                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5046
5047 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5048                 s->scalability=0;
5049
5050                 *gb= bak;
5051             }else
5052                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5053
5054             // bin shape stuff FIXME
5055         }
5056     }
5057     return 0;
5058 }
5059
5060 /**
5061  * decodes the user data stuff in the header.
5062  * allso inits divx/xvid/lavc_version/build
5063  */
5064 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5065     char buf[256];
5066     int i;
5067     int e;
5068     int ver, build, ver2, ver3;
5069     char last;
5070
5071     buf[0]= show_bits(gb, 8);
5072     for(i=1; i<256; i++){
5073         buf[i]= show_bits(gb, 16)&0xFF;
5074         if(buf[i]==0) break;
5075         skip_bits(gb, 8);
5076     }
5077     buf[255]=0;
5078
5079     /* divx detection */
5080     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5081     if(e<2)
5082         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5083     if(e>=2){
5084         s->divx_version= ver;
5085         s->divx_build= build;
5086         s->divx_packed= e==3 && last=='p';
5087     }
5088
5089     /* ffmpeg detection */
5090     e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
5091     if(e!=4)
5092         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5093     if(e!=4){
5094         if(strcmp(buf, "ffmpeg")==0){
5095             s->ffmpeg_version= 0x000406;
5096             s->lavc_build= 4600;
5097         }
5098     }
5099     if(e==4){
5100         s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
5101         s->lavc_build= build;
5102     }
5103
5104     /* xvid detection */
5105     e=sscanf(buf, "XviD%d", &build);
5106     if(e==1){
5107         s->xvid_build= build;
5108     }
5109
5110 //printf("User Data: %s\n", buf);
5111     return 0;
5112 }
5113
5114 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5115     int time_incr, time_increment;
5116
5117     s->pict_type = get_bits(gb, 2) + I_TYPE;    /* pict type: I = 0 , P = 1 */
5118     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5119         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n");
5120         s->low_delay=0;
5121     }
5122
5123     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5124     if(s->partitioned_frame)
5125         s->decode_mb= mpeg4_decode_partitioned_mb;
5126     else
5127         s->decode_mb= ff_h263_decode_mb;
5128
5129     if(s->time_increment_resolution==0){
5130         s->time_increment_resolution=1;
5131 //        fprintf(stderr, "time_increment_resolution is illegal\n");
5132     }
5133     time_incr=0;
5134     while (get_bits1(gb) != 0)
5135         time_incr++;
5136
5137     check_marker(gb, "before time_increment");
5138
5139     if(s->time_increment_bits==0){
5140         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
5141
5142         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5143             if(show_bits(gb, s->time_increment_bits+1)&1) break;
5144         }
5145
5146         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5147     }
5148
5149     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5150     else time_increment= get_bits(gb, s->time_increment_bits);
5151
5152 //    printf("%d %X\n", s->time_increment_bits, time_increment);
5153 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
5154     if(s->pict_type!=B_TYPE){
5155         s->last_time_base= s->time_base;
5156         s->time_base+= time_incr;
5157         s->time= s->time_base*s->time_increment_resolution + time_increment;
5158         if(s->workaround_bugs&FF_BUG_UMP4){
5159             if(s->time < s->last_non_b_time){
5160 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5161                 s->time_base++;
5162                 s->time+= s->time_increment_resolution;
5163             }
5164         }
5165         s->pp_time= s->time - s->last_non_b_time;
5166         s->last_non_b_time= s->time;
5167     }else{
5168         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
5169         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5170         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5171 //            printf("messed up order, seeking?, skiping current b frame\n");
5172             return FRAME_SKIPED;
5173         }
5174
5175         if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
5176         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5177 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
5178         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5179                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5180         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
5181                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5182     }
5183
5184     s->current_picture_ptr->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
5185     if(s->avctx->debug&FF_DEBUG_PTS)
5186         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(1000.0*1000.0));
5187
5188     check_marker(gb, "before vop_coded");
5189
5190     /* vop coded */
5191     if (get_bits1(gb) != 1){
5192         av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5193         return FRAME_SKIPED;
5194     }
5195 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
5196 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5197     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5198                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5199         /* rounding type for motion estimation */
5200         s->no_rounding = get_bits1(gb);
5201     } else {
5202         s->no_rounding = 0;
5203     }
5204 //FIXME reduced res stuff
5205
5206      if (s->shape != RECT_SHAPE) {
5207          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5208              int width, height, hor_spat_ref, ver_spat_ref;
5209
5210              width = get_bits(gb, 13);
5211              skip_bits1(gb);   /* marker */
5212              height = get_bits(gb, 13);
5213              skip_bits1(gb);   /* marker */
5214              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5215              skip_bits1(gb);   /* marker */
5216              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5217          }
5218          skip_bits1(gb); /* change_CR_disable */
5219
5220          if (get_bits1(gb) != 0) {
5221              skip_bits(gb, 8); /* constant_alpha_value */
5222          }
5223      }
5224 //FIXME complexity estimation stuff
5225
5226      if (s->shape != BIN_ONLY_SHAPE) {
5227          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5228          if(!s->progressive_sequence){
5229              s->top_field_first= get_bits1(gb);
5230              s->alternate_scan= get_bits1(gb);
5231          }else
5232              s->alternate_scan= 0;
5233      }
5234
5235      if(s->alternate_scan){
5236          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
5237          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
5238          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5239          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5240      } else{
5241          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
5242          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
5243          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5244          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5245      }
5246
5247      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5248          mpeg4_decode_sprite_trajectory(s);
5249          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5250          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5251      }
5252
5253      if (s->shape != BIN_ONLY_SHAPE) {
5254          s->qscale = get_bits(gb, s->quant_precision);
5255          if(s->qscale==0){
5256              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5257              return -1; // makes no sense to continue, as there is nothing left from the image then
5258          }
5259
5260          if (s->pict_type != I_TYPE) {
5261              s->f_code = get_bits(gb, 3);       /* fcode_for */
5262              if(s->f_code==0){
5263                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5264                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
5265              }
5266          }else
5267              s->f_code=1;
5268
5269          if (s->pict_type == B_TYPE) {
5270              s->b_code = get_bits(gb, 3);
5271          }else
5272              s->b_code=1;
5273
5274          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5275              av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n",
5276                  s->qscale, s->f_code, s->b_code,
5277                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5278                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5279                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5280                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5281          }
5282
5283          if(!s->scalability){
5284              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5285                  skip_bits1(gb); // vop shape coding type
5286              }
5287          }else{
5288              if(s->enhancement_type){
5289                  int load_backward_shape= get_bits1(gb);
5290                  if(load_backward_shape){
5291                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isnt supported\n");
5292                  }
5293              }
5294              skip_bits(gb, 2); //ref_select_code
5295          }
5296      }
5297      /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
5298      // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
5299      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5300          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5301          s->low_delay=1;
5302      }
5303
5304      s->picture_number++; // better than pic number==0 allways ;)
5305
5306      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5307      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5308
5309      if(s->workaround_bugs&FF_BUG_EDGE){
5310          s->h_edge_pos= s->width;
5311          s->v_edge_pos= s->height;
5312      }
5313      return 0;
5314 }
5315
5316 /**
5317  * decode mpeg4 headers
5318  * @return <0 if no VOP found (or a damaged one)
5319  *         FRAME_SKIPPED if a not coded VOP is found
5320  *         0 if a VOP is found
5321  */
5322 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
5323 {
5324     int startcode, v;
5325
5326     /* search next start code */
5327     align_get_bits(gb);
5328     startcode = 0xff;
5329     for(;;) {
5330         v = get_bits(gb, 8);
5331         startcode = ((startcode << 8) | v) & 0xffffffff;
5332
5333         if(get_bits_count(gb) >= gb->size_in_bits){
5334             if(gb->size_in_bits==8 && s->divx_version){
5335                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
5336                 return FRAME_SKIPED; //divx bug
5337             }else
5338                 return -1; //end of stream
5339         }
5340
5341         if((startcode&0xFFFFFF00) != 0x100)
5342             continue; //no startcode
5343
5344         if(s->avctx->debug&FF_DEBUG_STARTCODE){
5345             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
5346             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
5347             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
5348             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
5349             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
5350             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
5351             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
5352             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
5353             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
5354             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
5355             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
5356             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
5357             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
5358             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
5359             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
5360             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
5361             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
5362             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
5363             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
5364             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
5365             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start");
5366             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start");
5367             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start");
5368             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start");
5369             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start");
5370             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
5371             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
5372             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
5373             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
5374         }
5375
5376         if(startcode >= 0x120 && startcode <= 0x12F){
5377             if(decode_vol_header(s, gb) < 0)
5378                 return -1;
5379         }
5380         else if(startcode == USER_DATA_STARTCODE){
5381             decode_user_data(s, gb);
5382         }
5383         else if(startcode == GOP_STARTCODE){
5384             mpeg4_decode_gop_header(s, gb);
5385         }
5386         else if(startcode == VOP_STARTCODE){
5387             return decode_vop_header(s, gb);
5388         }
5389
5390         align_get_bits(gb);
5391         startcode = 0xff;
5392     }
5393 }
5394
5395 /* don't understand why they choose a different header ! */
5396 int intel_h263_decode_picture_header(MpegEncContext *s)
5397 {
5398     int format;
5399
5400     /* picture header */
5401     if (get_bits_long(&s->gb, 22) != 0x20) {
5402         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5403         return -1;
5404     }
5405     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5406
5407     if (get_bits1(&s->gb) != 1) {
5408         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5409         return -1;      /* marker */
5410     }
5411     if (get_bits1(&s->gb) != 0) {
5412         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5413         return -1;      /* h263 id */
5414     }
5415     skip_bits1(&s->gb); /* split screen off */
5416     skip_bits1(&s->gb); /* camera  off */
5417     skip_bits1(&s->gb); /* freeze picture release off */
5418
5419     format = get_bits(&s->gb, 3);
5420     if (format != 7) {
5421         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
5422         return -1;
5423     }
5424     s->h263_plus = 0;
5425
5426     s->pict_type = I_TYPE + get_bits1(&s->gb);
5427
5428     s->unrestricted_mv = get_bits1(&s->gb);
5429     s->h263_long_vectors = s->unrestricted_mv;
5430
5431     if (get_bits1(&s->gb) != 0) {
5432         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
5433         return -1;      /* SAC: off */
5434     }
5435     if (get_bits1(&s->gb) != 0) {
5436         s->obmc= 1;
5437         av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
5438 //        return -1;    /* advanced prediction mode: off */
5439     }
5440     if (get_bits1(&s->gb) != 0) {
5441         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
5442         return -1;      /* PB frame mode */
5443     }
5444
5445     /* skip unknown header garbage */
5446     skip_bits(&s->gb, 41);
5447
5448     s->qscale = get_bits(&s->gb, 5);
5449     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5450
5451     /* PEI */
5452     while (get_bits1(&s->gb) != 0) {
5453         skip_bits(&s->gb, 8);
5454     }
5455     s->f_code = 1;
5456
5457     s->y_dc_scale_table=
5458     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5459
5460     return 0;
5461 }
5462
5463 int flv_h263_decode_picture_header(MpegEncContext *s)
5464 {
5465     int format, width, height;
5466
5467     /* picture header */
5468     if (get_bits_long(&s->gb, 17) != 1) {
5469         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5470         return -1;
5471     }
5472     format = get_bits(&s->gb, 5);
5473     if (format != 0 && format != 1) {
5474         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
5475         return -1;
5476     }
5477     s->h263_flv = format+1;
5478     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5479     format = get_bits(&s->gb, 3);
5480     switch (format) {
5481     case 0:
5482         width = get_bits(&s->gb, 8);
5483         height = get_bits(&s->gb, 8);
5484         break;
5485     case 1:
5486         width = get_bits(&s->gb, 16);
5487         height = get_bits(&s->gb, 16);
5488         break;
5489     case 2:
5490         width = 352;
5491         height = 288;
5492         break;
5493     case 3:
5494         width = 176;
5495         height = 144;
5496         break;
5497     case 4:
5498         width = 128;
5499         height = 96;
5500         break;
5501     case 5:
5502         width = 320;
5503         height = 240;
5504         break;
5505     case 6:
5506         width = 160;
5507         height = 120;
5508         break;
5509     default:
5510         width = height = 0;
5511         break;
5512     }
5513     if ((width == 0) || (height == 0))
5514         return -1;
5515     s->width = width;
5516     s->height = height;
5517
5518     s->pict_type = I_TYPE + get_bits(&s->gb, 2);
5519     if (s->pict_type > P_TYPE)
5520         s->pict_type = P_TYPE;
5521     skip_bits1(&s->gb); /* deblocking flag */
5522     s->qscale = get_bits(&s->gb, 5);
5523
5524     s->h263_plus = 0;
5525
5526     s->unrestricted_mv = 1;
5527     s->h263_long_vectors = 0;
5528
5529     /* PEI */
5530     while (get_bits1(&s->gb) != 0) {
5531         skip_bits(&s->gb, 8);
5532     }
5533     s->f_code = 1;
5534
5535     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
5536         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
5537                av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
5538     }
5539
5540     s->y_dc_scale_table=
5541     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5542
5543     return 0;
5544 }