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