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