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