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
1965         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1966
1967             s->avctx->extradata= av_malloc(1024);
1968             init_put_bits(&s->pb, s->avctx->extradata, 1024);
1969
1970             mpeg4_encode_visual_object_header(s);
1971             mpeg4_encode_vol_header(s, 0, 0);
1972
1973 //            ff_mpeg4_stuffing(&s->pb); ?
1974             flush_put_bits(&s->pb);
1975             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1976         }
1977
1978         break;
1979     case CODEC_ID_H263P:
1980         if(s->umvplus)
1981             s->fcode_tab= umv_fcode_tab;
1982         if(s->modified_quant){
1983             s->min_qcoeff= -2047;
1984             s->max_qcoeff=  2047;
1985         }else{
1986             s->min_qcoeff= -127;
1987             s->max_qcoeff=  127;
1988         }
1989         break;
1990         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1991     case CODEC_ID_FLV1:
1992         if (s->h263_flv > 1) {
1993             s->min_qcoeff= -1023;
1994             s->max_qcoeff=  1023;
1995         } else {
1996             s->min_qcoeff= -127;
1997             s->max_qcoeff=  127;
1998         }
1999         s->y_dc_scale_table=
2000         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2001         break;
2002     default: //nothing needed default table allready set in mpegvideo.c
2003         s->min_qcoeff= -127;
2004         s->max_qcoeff=  127;
2005         s->y_dc_scale_table=
2006         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2007     }
2008 }
2009
2010 /**
2011  * encodes a 8x8 block.
2012  * @param block the 8x8 block
2013  * @param n block index (0-3 are luma, 4-5 are chroma)
2014  */
2015 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2016 {
2017     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2018     RLTable *rl;
2019
2020     rl = &rl_inter;
2021     if (s->mb_intra && !s->h263_aic) {
2022         /* DC coef */
2023         level = block[0];
2024         /* 255 cannot be represented, so we clamp */
2025         if (level > 254) {
2026             level = 254;
2027             block[0] = 254;
2028         }
2029         /* 0 cannot be represented also */
2030         else if (level < 1) {
2031             level = 1;
2032             block[0] = 1;
2033         }
2034         if (level == 128) //FIXME check rv10
2035             put_bits(&s->pb, 8, 0xff);
2036         else
2037             put_bits(&s->pb, 8, level);
2038         i = 1;
2039     } else {
2040         i = 0;
2041         if (s->h263_aic && s->mb_intra)
2042             rl = &rl_intra_aic;
2043
2044         if(s->alt_inter_vlc && !s->mb_intra){
2045             int aic_vlc_bits=0;
2046             int inter_vlc_bits=0;
2047             int wrong_pos=-1;
2048             int aic_code;
2049
2050             last_index = s->block_last_index[n];
2051             last_non_zero = i - 1;
2052             for (; i <= last_index; i++) {
2053                 j = s->intra_scantable.permutated[i];
2054                 level = block[j];
2055                 if (level) {
2056                     run = i - last_non_zero - 1;
2057                     last = (i == last_index);
2058
2059                     if(level<0) level= -level;
2060
2061                     code = get_rl_index(rl, last, run, level);
2062                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2063                     inter_vlc_bits += rl->table_vlc[code][1]+1;
2064                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2065
2066                     if (code == rl->n) {
2067                         inter_vlc_bits += 1+6+8-1;
2068                     }
2069                     if (aic_code == rl_intra_aic.n) {
2070                         aic_vlc_bits += 1+6+8-1;
2071                         wrong_pos += run + 1;
2072                     }else
2073                         wrong_pos += wrong_run[aic_code];
2074                     last_non_zero = i;
2075                 }
2076             }
2077             i = 0;
2078             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2079                 rl = &rl_intra_aic;
2080         }
2081     }
2082
2083     /* AC coefs */
2084     last_index = s->block_last_index[n];
2085     last_non_zero = i - 1;
2086     for (; i <= last_index; i++) {
2087         j = s->intra_scantable.permutated[i];
2088         level = block[j];
2089         if (level) {
2090             run = i - last_non_zero - 1;
2091             last = (i == last_index);
2092             sign = 0;
2093             slevel = level;
2094             if (level < 0) {
2095                 sign = 1;
2096                 level = -level;
2097             }
2098             code = get_rl_index(rl, last, run, level);
2099             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2100             if (code == rl->n) {
2101               if(s->h263_flv <= 1){
2102                 put_bits(&s->pb, 1, last);
2103                 put_bits(&s->pb, 6, run);
2104
2105                 assert(slevel != 0);
2106
2107                 if(level < 128)
2108                     put_bits(&s->pb, 8, slevel & 0xff);
2109                 else{
2110                     put_bits(&s->pb, 8, 128);
2111                     put_bits(&s->pb, 5, slevel & 0x1f);
2112                     put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2113                 }
2114               }else{
2115                 if(level < 64) { // 7-bit level
2116                         put_bits(&s->pb, 1, 0);
2117                         put_bits(&s->pb, 1, last);
2118                         put_bits(&s->pb, 6, run);
2119
2120                         put_bits(&s->pb, 7, slevel & 0x7f);
2121                     } else {
2122                         /* 11-bit level */
2123                         put_bits(&s->pb, 1, 1);
2124                         put_bits(&s->pb, 1, last);
2125                         put_bits(&s->pb, 6, run);
2126
2127                         put_bits(&s->pb, 11, slevel & 0x7ff);
2128                     }
2129               }
2130             } else {
2131                 put_bits(&s->pb, 1, sign);
2132             }
2133             last_non_zero = i;
2134         }
2135     }
2136 }
2137 #endif
2138
2139 #ifdef CONFIG_ENCODERS
2140
2141 /***************************************************/
2142 /**
2143  * add mpeg4 stuffing bits (01...1)
2144  */
2145 void ff_mpeg4_stuffing(PutBitContext * pbc)
2146 {
2147     int length;
2148     put_bits(pbc, 1, 0);
2149     length= (-put_bits_count(pbc))&7;
2150     if(length) put_bits(pbc, length, (1<<length)-1);
2151 }
2152
2153 /* must be called before writing the header */
2154 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2155     int time_div, time_mod;
2156
2157     if(s->current_picture_ptr->pts)
2158         s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
2159     else
2160         s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
2161     time_div= s->time/s->time_increment_resolution;
2162     time_mod= s->time%s->time_increment_resolution;
2163
2164     if(s->pict_type==B_TYPE){
2165         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2166     }else{
2167         s->last_time_base= s->time_base;
2168         s->time_base= time_div;
2169         s->pp_time= s->time - s->last_non_b_time;
2170         s->last_non_b_time= s->time;
2171     }
2172 }
2173
2174 static void mpeg4_encode_gop_header(MpegEncContext * s){
2175     int hours, minutes, seconds;
2176     int64_t time;
2177
2178     put_bits(&s->pb, 16, 0);
2179     put_bits(&s->pb, 16, GOP_STARTCODE);
2180
2181     if(s->current_picture_ptr->pts && s->reordered_input_picture[1]){
2182         time= FFMIN(s->reordered_input_picture[1]->pts, s->current_picture_ptr->pts);
2183         time= (time*s->time_increment_resolution + 500*1000)/(1000*1000);
2184     }else
2185         time= av_rescale(s->current_picture_ptr->coded_picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
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=0);             /* sprite enable */
2294     }else{
2295         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
2296     }
2297
2298     s->quant_precision=5;
2299     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2300     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2301
2302     if(s->mpeg_quant){
2303         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2304         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2305     }
2306
2307     if (vo_ver_id != 1)
2308         put_bits(&s->pb, 1, s->quarter_sample);
2309     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2310     s->resync_marker= s->rtp_mode;
2311     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2312     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2313     if(s->data_partitioning){
2314         put_bits(&s->pb, 1, 0);         /* no rvlc */
2315     }
2316
2317     if (vo_ver_id != 1){
2318         put_bits(&s->pb, 1, 0);         /* newpred */
2319         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2320     }
2321     put_bits(&s->pb, 1, 0);             /* scalability */
2322
2323     ff_mpeg4_stuffing(&s->pb);
2324
2325     /* user data */
2326     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2327         put_bits(&s->pb, 16, 0);
2328         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2329         put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2330     }
2331 }
2332
2333 /* write mpeg4 VOP header */
2334 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2335 {
2336     int time_incr;
2337     int time_div, time_mod;
2338
2339     if(s->pict_type==I_TYPE){
2340         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2341             if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2342                 mpeg4_encode_visual_object_header(s);
2343             if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2344                 mpeg4_encode_vol_header(s, 0, 0);
2345         }
2346         mpeg4_encode_gop_header(s);
2347     }
2348
2349     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2350
2351 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2352
2353     put_bits(&s->pb, 16, 0);            /* vop header */
2354     put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2355     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
2356
2357     time_div= s->time/s->time_increment_resolution;
2358     time_mod= s->time%s->time_increment_resolution;
2359     time_incr= time_div - s->last_time_base;
2360     while(time_incr--)
2361         put_bits(&s->pb, 1, 1);
2362
2363     put_bits(&s->pb, 1, 0);
2364
2365     put_bits(&s->pb, 1, 1);     /* marker */
2366     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2367     put_bits(&s->pb, 1, 1);     /* marker */
2368     put_bits(&s->pb, 1, 1);     /* vop coded */
2369     if (    s->pict_type == P_TYPE
2370         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2371         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2372     }
2373     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2374     if(!s->progressive_sequence){
2375          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2376          put_bits(&s->pb, 1, s->alternate_scan);
2377     }
2378     //FIXME sprite stuff
2379
2380     put_bits(&s->pb, 5, s->qscale);
2381
2382     if (s->pict_type != I_TYPE)
2383         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2384     if (s->pict_type == B_TYPE)
2385         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2386     //    printf("****frame %d\n", picture_number);
2387
2388      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
2389      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2390 }
2391
2392 #endif //CONFIG_ENCODERS
2393
2394 /**
2395  * set qscale and update qscale dependant variables.
2396  */
2397 void ff_set_qscale(MpegEncContext * s, int qscale)
2398 {
2399     if (qscale < 1)
2400         qscale = 1;
2401     else if (qscale > 31)
2402         qscale = 31;
2403
2404     s->qscale = qscale;
2405     s->chroma_qscale= s->chroma_qscale_table[qscale];
2406
2407     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2408     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2409 }
2410
2411 /**
2412  * predicts the dc.
2413  * @param n block index (0-3 are luma, 4-5 are chroma)
2414  * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2415  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2416  * @return the quantized predicted dc
2417  */
2418 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2419 {
2420     int a, b, c, wrap, pred, scale;
2421     uint16_t *dc_val;
2422
2423     /* find prediction */
2424     if (n < 4) {
2425         scale = s->y_dc_scale;
2426     } else {
2427         scale = s->c_dc_scale;
2428     }
2429     if(IS_3IV1)
2430         scale= 8;
2431
2432     wrap= s->block_wrap[n];
2433     dc_val = s->dc_val[0] + s->block_index[n];
2434
2435     /* B C
2436      * A X
2437      */
2438     a = dc_val[ - 1];
2439     b = dc_val[ - 1 - wrap];
2440     c = dc_val[ - wrap];
2441
2442     /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2443     if(s->first_slice_line && n!=3){
2444         if(n!=2) b=c= 1024;
2445         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2446     }
2447     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2448         if(n==0 || n==4 || n==5)
2449             b=1024;
2450     }
2451
2452     if (abs(a - b) < abs(b - c)) {
2453         pred = c;
2454         *dir_ptr = 1; /* top */
2455     } else {
2456         pred = a;
2457         *dir_ptr = 0; /* left */
2458     }
2459     /* we assume pred is positive */
2460     pred = FASTDIV((pred + (scale >> 1)), scale);
2461
2462     /* prepare address for prediction update */
2463     *dc_val_ptr = &dc_val[0];
2464
2465     return pred;
2466 }
2467
2468 /**
2469  * predicts the ac.
2470  * @param n block index (0-3 are luma, 4-5 are chroma)
2471  * @param dir the ac prediction direction
2472  */
2473 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2474                    int dir)
2475 {
2476     int i;
2477     int16_t *ac_val, *ac_val1;
2478     int8_t * const qscale_table= s->current_picture.qscale_table;
2479
2480     /* find prediction */
2481     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2482     ac_val1 = ac_val;
2483     if (s->ac_pred) {
2484         if (dir == 0) {
2485             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2486             /* left prediction */
2487             ac_val -= 16;
2488
2489             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2490                 /* same qscale */
2491                 for(i=1;i<8;i++) {
2492                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2493                 }
2494             }else{
2495                 /* different qscale, we must rescale */
2496                 for(i=1;i<8;i++) {
2497                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2498                 }
2499             }
2500         } else {
2501             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2502             /* top prediction */
2503             ac_val -= 16 * s->block_wrap[n];
2504
2505             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2506                 /* same qscale */
2507                 for(i=1;i<8;i++) {
2508                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2509                 }
2510             }else{
2511                 /* different qscale, we must rescale */
2512                 for(i=1;i<8;i++) {
2513                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2514                 }
2515             }
2516         }
2517     }
2518     /* left copy */
2519     for(i=1;i<8;i++)
2520         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2521
2522     /* top copy */
2523     for(i=1;i<8;i++)
2524         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2525
2526 }
2527
2528 #ifdef CONFIG_ENCODERS
2529
2530 /**
2531  * encodes the dc value.
2532  * @param n block index (0-3 are luma, 4-5 are chroma)
2533  */
2534 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2535 {
2536 #if 1
2537 //    if(level<-255 || level>255) printf("dc overflow\n");
2538     level+=256;
2539     if (n < 4) {
2540         /* luminance */
2541         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2542     } else {
2543         /* chrominance */
2544         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2545     }
2546 #else
2547     int size, v;
2548     /* find number of bits */
2549     size = 0;
2550     v = abs(level);
2551     while (v) {
2552         v >>= 1;
2553         size++;
2554     }
2555
2556     if (n < 4) {
2557         /* luminance */
2558         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2559     } else {
2560         /* chrominance */
2561         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2562     }
2563
2564     /* encode remaining bits */
2565     if (size > 0) {
2566         if (level < 0)
2567             level = (-level) ^ ((1 << size) - 1);
2568         put_bits(&s->pb, size, level);
2569         if (size > 8)
2570             put_bits(&s->pb, 1, 1);
2571     }
2572 #endif
2573 }
2574
2575 /**
2576  * encodes a 8x8 block
2577  * @param n block index (0-3 are luma, 4-5 are chroma)
2578  */
2579 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2580                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2581 {
2582     int i, last_non_zero;
2583 #if 0 //variables for the outcommented version
2584     int code, sign, last;
2585 #endif
2586     const RLTable *rl;
2587     uint32_t *bits_tab;
2588     uint8_t *len_tab;
2589     const int last_index = s->block_last_index[n];
2590
2591     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2592         /* mpeg4 based DC predictor */
2593         mpeg4_encode_dc(dc_pb, intra_dc, n);
2594         if(last_index<1) return;
2595         i = 1;
2596         rl = &rl_intra;
2597         bits_tab= uni_mpeg4_intra_rl_bits;
2598         len_tab = uni_mpeg4_intra_rl_len;
2599     } else {
2600         if(last_index<0) return;
2601         i = 0;
2602         rl = &rl_inter;
2603         bits_tab= uni_mpeg4_inter_rl_bits;
2604         len_tab = uni_mpeg4_inter_rl_len;
2605     }
2606
2607     /* AC coefs */
2608     last_non_zero = i - 1;
2609 #if 1
2610     for (; i < last_index; i++) {
2611         int level = block[ scan_table[i] ];
2612         if (level) {
2613             int run = i - last_non_zero - 1;
2614             level+=64;
2615             if((level&(~127)) == 0){
2616                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2617                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2618             }else{ //ESC3
2619                 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);
2620             }
2621             last_non_zero = i;
2622         }
2623     }
2624     /*if(i<=last_index)*/{
2625         int level = block[ scan_table[i] ];
2626         int run = i - last_non_zero - 1;
2627         level+=64;
2628         if((level&(~127)) == 0){
2629             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2630             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2631         }else{ //ESC3
2632             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);
2633         }
2634     }
2635 #else
2636     for (; i <= last_index; i++) {
2637         const int slevel = block[ scan_table[i] ];
2638         if (slevel) {
2639             int level;
2640             int run = i - last_non_zero - 1;
2641             last = (i == last_index);
2642             sign = 0;
2643             level = slevel;
2644             if (level < 0) {
2645                 sign = 1;
2646                 level = -level;
2647             }
2648             code = get_rl_index(rl, last, run, level);
2649             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2650             if (code == rl->n) {
2651                 int level1, run1;
2652                 level1 = level - rl->max_level[last][run];
2653                 if (level1 < 1)
2654                     goto esc2;
2655                 code = get_rl_index(rl, last, run, level1);
2656                 if (code == rl->n) {
2657                 esc2:
2658                     put_bits(ac_pb, 1, 1);
2659                     if (level > MAX_LEVEL)
2660                         goto esc3;
2661                     run1 = run - rl->max_run[last][level] - 1;
2662                     if (run1 < 0)
2663                         goto esc3;
2664                     code = get_rl_index(rl, last, run1, level);
2665                     if (code == rl->n) {
2666                     esc3:
2667                         /* third escape */
2668                         put_bits(ac_pb, 1, 1);
2669                         put_bits(ac_pb, 1, last);
2670                         put_bits(ac_pb, 6, run);
2671                         put_bits(ac_pb, 1, 1);
2672                         put_bits(ac_pb, 12, slevel & 0xfff);
2673                         put_bits(ac_pb, 1, 1);
2674                     } else {
2675                         /* second escape */
2676                         put_bits(ac_pb, 1, 0);
2677                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2678                         put_bits(ac_pb, 1, sign);
2679                     }
2680                 } else {
2681                     /* first escape */
2682                     put_bits(ac_pb, 1, 0);
2683                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2684                     put_bits(ac_pb, 1, sign);
2685                 }
2686             } else {
2687                 put_bits(ac_pb, 1, sign);
2688             }
2689             last_non_zero = i;
2690         }
2691     }
2692 #endif
2693 }
2694
2695 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2696                                uint8_t *scan_table)
2697 {
2698     int i, last_non_zero;
2699     const RLTable *rl;
2700     uint8_t *len_tab;
2701     const int last_index = s->block_last_index[n];
2702     int len=0;
2703
2704     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2705         /* mpeg4 based DC predictor */
2706         //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2707         if(last_index<1) return len;
2708         i = 1;
2709         rl = &rl_intra;
2710         len_tab = uni_mpeg4_intra_rl_len;
2711     } else {
2712         if(last_index<0) return 0;
2713         i = 0;
2714         rl = &rl_inter;
2715         len_tab = uni_mpeg4_inter_rl_len;
2716     }
2717
2718     /* AC coefs */
2719     last_non_zero = i - 1;
2720     for (; i < last_index; i++) {
2721         int level = block[ scan_table[i] ];
2722         if (level) {
2723             int run = i - last_non_zero - 1;
2724             level+=64;
2725             if((level&(~127)) == 0){
2726                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2727                 len += len_tab[index];
2728             }else{ //ESC3
2729                 len += 7+2+1+6+1+12+1;
2730             }
2731             last_non_zero = i;
2732         }
2733     }
2734     /*if(i<=last_index)*/{
2735         int level = block[ scan_table[i] ];
2736         int run = i - last_non_zero - 1;
2737         level+=64;
2738         if((level&(~127)) == 0){
2739             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2740             len += len_tab[index];
2741         }else{ //ESC3
2742             len += 7+2+1+6+1+12+1;
2743         }
2744     }
2745
2746     return len;
2747 }
2748
2749 #endif
2750
2751
2752 /***********************************************/
2753 /* decoding */
2754
2755 static VLC intra_MCBPC_vlc;
2756 static VLC inter_MCBPC_vlc;
2757 static VLC cbpy_vlc;
2758 static VLC mv_vlc;
2759 static VLC dc_lum, dc_chrom;
2760 static VLC sprite_trajectory;
2761 static VLC mb_type_b_vlc;
2762 static VLC h263_mbtype_b_vlc;
2763 static VLC cbpc_b_vlc;
2764
2765 void init_vlc_rl(RLTable *rl)
2766 {
2767     int i, q;
2768
2769     init_vlc(&rl->vlc, 9, rl->n + 1,
2770              &rl->table_vlc[0][1], 4, 2,
2771              &rl->table_vlc[0][0], 4, 2);
2772
2773
2774     for(q=0; q<32; q++){
2775         int qmul= q*2;
2776         int qadd= (q-1)|1;
2777
2778         if(q==0){
2779             qmul=1;
2780             qadd=0;
2781         }
2782
2783         rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2784         for(i=0; i<rl->vlc.table_size; i++){
2785             int code= rl->vlc.table[i][0];
2786             int len = rl->vlc.table[i][1];
2787             int level, run;
2788
2789             if(len==0){ // illegal code
2790                 run= 66;
2791                 level= MAX_LEVEL;
2792             }else if(len<0){ //more bits needed
2793                 run= 0;
2794                 level= code;
2795             }else{
2796                 if(code==rl->n){ //esc
2797                     run= 66;
2798                     level= 0;
2799                 }else{
2800                     run=   rl->table_run  [code] + 1;
2801                     level= rl->table_level[code] * qmul + qadd;
2802                     if(code >= rl->last) run+=192;
2803                 }
2804             }
2805             rl->rl_vlc[q][i].len= len;
2806             rl->rl_vlc[q][i].level= level;
2807             rl->rl_vlc[q][i].run= run;
2808         }
2809     }
2810 }
2811
2812 /* init vlcs */
2813
2814 /* XXX: find a better solution to handle static init */
2815 void h263_decode_init_vlc(MpegEncContext *s)
2816 {
2817     static int done = 0;
2818
2819     if (!done) {
2820         done = 1;
2821
2822         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2823                  intra_MCBPC_bits, 1, 1,
2824                  intra_MCBPC_code, 1, 1);
2825         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2826                  inter_MCBPC_bits, 1, 1,
2827                  inter_MCBPC_code, 1, 1);
2828         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2829                  &cbpy_tab[0][1], 2, 1,
2830                  &cbpy_tab[0][0], 2, 1);
2831         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2832                  &mvtab[0][1], 2, 1,
2833                  &mvtab[0][0], 2, 1);
2834         init_rl(&rl_inter);
2835         init_rl(&rl_intra);
2836         init_rl(&rvlc_rl_inter);
2837         init_rl(&rvlc_rl_intra);
2838         init_rl(&rl_intra_aic);
2839         init_vlc_rl(&rl_inter);
2840         init_vlc_rl(&rl_intra);
2841         init_vlc_rl(&rvlc_rl_inter);
2842         init_vlc_rl(&rvlc_rl_intra);
2843         init_vlc_rl(&rl_intra_aic);
2844         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2845                  &DCtab_lum[0][1], 2, 1,
2846                  &DCtab_lum[0][0], 2, 1);
2847         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2848                  &DCtab_chrom[0][1], 2, 1,
2849                  &DCtab_chrom[0][0], 2, 1);
2850         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2851                  &sprite_trajectory_tab[0][1], 4, 2,
2852                  &sprite_trajectory_tab[0][0], 4, 2);
2853         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2854                  &mb_type_b_tab[0][1], 2, 1,
2855                  &mb_type_b_tab[0][0], 2, 1);
2856         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2857                  &h263_mbtype_b_tab[0][1], 2, 1,
2858                  &h263_mbtype_b_tab[0][0], 2, 1);
2859         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2860                  &cbpc_b_tab[0][1], 2, 1,
2861                  &cbpc_b_tab[0][0], 2, 1);
2862     }
2863 }
2864
2865 /**
2866  * Get the GOB height based on picture height.
2867  */
2868 int ff_h263_get_gob_height(MpegEncContext *s){
2869     if (s->height <= 400)
2870         return 1;
2871     else if (s->height <= 800)
2872         return  2;
2873     else
2874         return 4;
2875 }
2876
2877 int ff_h263_decode_mba(MpegEncContext *s)
2878 {
2879     int i, mb_pos;
2880
2881     for(i=0; i<6; i++){
2882         if(s->mb_num-1 <= ff_mba_max[i]) break;
2883     }
2884     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2885     s->mb_x= mb_pos % s->mb_width;
2886     s->mb_y= mb_pos / s->mb_width;
2887
2888     return mb_pos;
2889 }
2890
2891 void ff_h263_encode_mba(MpegEncContext *s)
2892 {
2893     int i, mb_pos;
2894
2895     for(i=0; i<6; i++){
2896         if(s->mb_num-1 <= ff_mba_max[i]) break;
2897     }
2898     mb_pos= s->mb_x + s->mb_width*s->mb_y;
2899     put_bits(&s->pb, ff_mba_length[i], mb_pos);
2900 }
2901
2902 /**
2903  * decodes the group of blocks header or slice header.
2904  * @return <0 if an error occured
2905  */
2906 static int h263_decode_gob_header(MpegEncContext *s)
2907 {
2908     unsigned int val, gfid, gob_number;
2909     int left;
2910
2911     /* Check for GOB Start Code */
2912     val = show_bits(&s->gb, 16);
2913     if(val)
2914         return -1;
2915
2916         /* We have a GBSC probably with GSTUFF */
2917     skip_bits(&s->gb, 16); /* Drop the zeros */
2918     left= s->gb.size_in_bits - get_bits_count(&s->gb);
2919     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2920     for(;left>13; left--){
2921         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2922     }
2923     if(left<=13)
2924         return -1;
2925
2926     if(s->h263_slice_structured){
2927         if(get_bits1(&s->gb)==0)
2928             return -1;
2929
2930         ff_h263_decode_mba(s);
2931
2932         if(s->mb_num > 1583)
2933             if(get_bits1(&s->gb)==0)
2934                 return -1;
2935
2936         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2937         if(get_bits1(&s->gb)==0)
2938             return -1;
2939         gfid = get_bits(&s->gb, 2); /* GFID */
2940     }else{
2941         gob_number = get_bits(&s->gb, 5); /* GN */
2942         s->mb_x= 0;
2943         s->mb_y= s->gob_index* gob_number;
2944         gfid = get_bits(&s->gb, 2); /* GFID */
2945         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2946     }
2947
2948     if(s->mb_y >= s->mb_height)
2949         return -1;
2950
2951     if(s->qscale==0)
2952         return -1;
2953
2954     return 0;
2955 }
2956
2957 static inline void memsetw(short *tab, int val, int n)
2958 {
2959     int i;
2960     for(i=0;i<n;i++)
2961         tab[i] = val;
2962 }
2963
2964 #ifdef CONFIG_ENCODERS
2965
2966 void ff_mpeg4_init_partitions(MpegEncContext *s)
2967 {
2968     init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2969     init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE);
2970 }
2971
2972 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2973 {
2974     const int pb2_len   = put_bits_count(&s->pb2   );
2975     const int tex_pb_len= put_bits_count(&s->tex_pb);
2976     const int bits= put_bits_count(&s->pb);
2977
2978     if(s->pict_type==I_TYPE){
2979         put_bits(&s->pb, 19, DC_MARKER);
2980         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2981         s->i_tex_bits+= tex_pb_len;
2982     }else{
2983         put_bits(&s->pb, 17, MOTION_MARKER);
2984         s->misc_bits+=17 + pb2_len;
2985         s->mv_bits+= bits - s->last_bits;
2986         s->p_tex_bits+= tex_pb_len;
2987     }
2988
2989     flush_put_bits(&s->pb2);
2990     flush_put_bits(&s->tex_pb);
2991
2992     ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2993     ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2994     s->last_bits= put_bits_count(&s->pb);
2995 }
2996
2997 #endif //CONFIG_ENCODERS
2998
2999 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3000     switch(s->pict_type){
3001         case I_TYPE:
3002             return 16;
3003         case P_TYPE:
3004         case S_TYPE:
3005             return s->f_code+15;
3006         case B_TYPE:
3007             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3008         default:
3009             return -1;
3010     }
3011 }
3012
3013 #ifdef CONFIG_ENCODERS
3014
3015 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3016 {
3017     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3018
3019     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3020     put_bits(&s->pb, 1, 1);
3021
3022     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3023     put_bits(&s->pb, s->quant_precision, s->qscale);
3024     put_bits(&s->pb, 1, 0); /* no HEC */
3025 }
3026
3027 #endif //CONFIG_ENCODERS
3028
3029 /**
3030  * check if the next stuff is a resync marker or the end.
3031  * @return 0 if not
3032  */
3033 static inline int mpeg4_is_resync(MpegEncContext *s){
3034     const int bits_count= get_bits_count(&s->gb);
3035
3036     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3037         return 0;
3038     }
3039
3040     if(bits_count + 8 >= s->gb.size_in_bits){
3041         int v= show_bits(&s->gb, 8);
3042         v|= 0x7F >> (7-(bits_count&7));
3043
3044         if(v==0x7F)
3045             return 1;
3046     }else{
3047         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3048             int len;
3049             GetBitContext gb= s->gb;
3050
3051             skip_bits(&s->gb, 1);
3052             align_get_bits(&s->gb);
3053
3054             for(len=0; len<32; len++){
3055                 if(get_bits1(&s->gb)) break;
3056             }
3057
3058             s->gb= gb;
3059
3060             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3061                 return 1;
3062         }
3063     }
3064     return 0;
3065 }
3066
3067 /**
3068  * decodes the next video packet.
3069  * @return <0 if something went wrong
3070  */
3071 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3072 {
3073     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3074     int header_extension=0, mb_num, len;
3075
3076     /* is there enough space left for a video packet + header */
3077     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3078
3079     for(len=0; len<32; len++){
3080         if(get_bits1(&s->gb)) break;
3081     }
3082
3083     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3084         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3085         return -1;
3086     }
3087
3088     if(s->shape != RECT_SHAPE){
3089         header_extension= get_bits1(&s->gb);
3090         //FIXME more stuff here
3091     }
3092
3093     mb_num= get_bits(&s->gb, mb_num_bits);
3094     if(mb_num>=s->mb_num){
3095         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3096         return -1;
3097     }
3098     if(s->pict_type == B_TYPE){
3099         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3100         if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3101     }
3102
3103     s->mb_x= mb_num % s->mb_width;
3104     s->mb_y= mb_num / s->mb_width;
3105
3106     if(s->shape != BIN_ONLY_SHAPE){
3107         int qscale= get_bits(&s->gb, s->quant_precision);
3108         if(qscale)
3109             s->chroma_qscale=s->qscale= qscale;
3110     }
3111
3112     if(s->shape == RECT_SHAPE){
3113         header_extension= get_bits1(&s->gb);
3114     }
3115     if(header_extension){
3116         int time_increment;
3117         int time_incr=0;
3118
3119         while (get_bits1(&s->gb) != 0)
3120             time_incr++;
3121
3122         check_marker(&s->gb, "before time_increment in video packed header");
3123         time_increment= get_bits(&s->gb, s->time_increment_bits);
3124         check_marker(&s->gb, "before vop_coding_type in video packed header");
3125
3126         skip_bits(&s->gb, 2); /* vop coding type */
3127         //FIXME not rect stuff here
3128
3129         if(s->shape != BIN_ONLY_SHAPE){
3130             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3131 //FIXME dont just ignore everything
3132             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3133                 mpeg4_decode_sprite_trajectory(s);
3134                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3135             }
3136
3137             //FIXME reduced res stuff here
3138
3139             if (s->pict_type != I_TYPE) {
3140                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3141                 if(f_code==0){
3142                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3143                 }
3144             }
3145             if (s->pict_type == B_TYPE) {
3146                 int b_code = get_bits(&s->gb, 3);
3147                 if(b_code==0){
3148                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3149                 }
3150             }
3151         }
3152     }
3153     //FIXME new-pred stuff
3154
3155 //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));
3156
3157     return 0;
3158 }
3159
3160 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3161 {
3162     int c_wrap, c_xy, l_wrap, l_xy;
3163
3164     l_wrap= s->block_wrap[0];
3165     l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
3166     c_wrap= s->block_wrap[4];
3167     c_xy= s->mb_y*c_wrap + s->mb_x;
3168
3169 #if 0
3170     /* clean DC */
3171     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3172     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3173     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3174 #endif
3175
3176     /* clean AC */
3177     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3178     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3179     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3180
3181     /* clean MV */
3182     // we cant clear the MVs as they might be needed by a b frame
3183 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3184 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3185     s->last_mv[0][0][0]=
3186     s->last_mv[0][0][1]=
3187     s->last_mv[1][0][0]=
3188     s->last_mv[1][0][1]= 0;
3189 }
3190
3191 /**
3192  * decodes the group of blocks / video packet header.
3193  * @return <0 if no resync found
3194  */
3195 int ff_h263_resync(MpegEncContext *s){
3196     int left, ret;
3197
3198     if(s->codec_id==CODEC_ID_MPEG4){
3199         skip_bits1(&s->gb);
3200         align_get_bits(&s->gb);
3201     }
3202
3203     if(show_bits(&s->gb, 16)==0){
3204         if(s->codec_id==CODEC_ID_MPEG4)
3205             ret= mpeg4_decode_video_packet_header(s);
3206         else
3207             ret= h263_decode_gob_header(s);
3208         if(ret>=0)
3209             return 0;
3210     }
3211     //ok, its not where its supposed to be ...
3212     s->gb= s->last_resync_gb;
3213     align_get_bits(&s->gb);
3214     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3215
3216     for(;left>16+1+5+5; left-=8){
3217         if(show_bits(&s->gb, 16)==0){
3218             GetBitContext bak= s->gb;
3219
3220             if(s->codec_id==CODEC_ID_MPEG4)
3221                 ret= mpeg4_decode_video_packet_header(s);
3222             else
3223                 ret= h263_decode_gob_header(s);
3224             if(ret>=0)
3225                 return 0;
3226
3227             s->gb= bak;
3228         }
3229         skip_bits(&s->gb, 8);
3230     }
3231
3232     return -1;
3233 }
3234
3235 /**
3236  * gets the average motion vector for a GMC MB.
3237  * @param n either 0 for the x component or 1 for y
3238  * @returns the average MV for a GMC MB
3239  */
3240 static inline int get_amv(MpegEncContext *s, int n){
3241     int x, y, mb_v, sum, dx, dy, shift;
3242     int len = 1 << (s->f_code + 4);
3243     const int a= s->sprite_warping_accuracy;
3244
3245     if(s->real_sprite_warping_points==1){
3246         if(s->divx_version==500 && s->divx_build==413)
3247             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3248         else
3249             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3250     }else{
3251         dx= s->sprite_delta[n][0];
3252         dy= s->sprite_delta[n][1];
3253         shift= s->sprite_shift[0];
3254         if(n) dy -= 1<<(shift + a + 1);
3255         else  dx -= 1<<(shift + a + 1);
3256         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3257
3258         sum=0;
3259         for(y=0; y<16; y++){
3260             int v;
3261
3262             v= mb_v + dy*y;
3263             //XXX FIXME optimize
3264             for(x=0; x<16; x++){
3265                 sum+= v>>shift;
3266                 v+= dx;
3267             }
3268         }
3269         sum= RSHIFT(sum, a+8-s->quarter_sample);
3270     }
3271
3272     if      (sum < -len) sum= -len;
3273     else if (sum >= len) sum= len-1;
3274
3275     return sum;
3276 }
3277
3278 /**
3279  * decodes first partition.
3280  * @return number of MBs decoded or <0 if an error occured
3281  */
3282 static int mpeg4_decode_partition_a(MpegEncContext *s){
3283     int mb_num;
3284     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3285
3286     /* decode first partition */
3287     mb_num=0;
3288     s->first_slice_line=1;
3289     for(; s->mb_y<s->mb_height; s->mb_y++){
3290         ff_init_block_index(s);
3291         for(; s->mb_x<s->mb_width; s->mb_x++){
3292             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3293             int cbpc;
3294             int dir=0;
3295
3296             mb_num++;
3297             ff_update_block_index(s);
3298             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3299                 s->first_slice_line=0;
3300
3301             if(s->pict_type==I_TYPE){
3302                 int i;
3303
3304                 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3305                     return mb_num-1;
3306                 }
3307
3308                 do{
3309                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3310                     if (cbpc < 0){
3311                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3312                         return -1;
3313                     }
3314                 }while(cbpc == 8);
3315
3316                 s->cbp_table[xy]= cbpc & 3;
3317                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3318                 s->mb_intra = 1;
3319
3320                 if(cbpc & 4) {
3321                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3322                 }
3323                 s->current_picture.qscale_table[xy]= s->qscale;
3324
3325                 s->mbintra_table[xy]= 1;
3326                 for(i=0; i<6; i++){
3327                     int dc_pred_dir;
3328                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3329                     if(dc < 0){
3330                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3331                         return -1;
3332                     }
3333                     dir<<=1;
3334                     if(dc_pred_dir) dir|=1;
3335                 }
3336                 s->pred_dir_table[xy]= dir;
3337             }else{ /* P/S_TYPE */
3338                 int mx, my, pred_x, pred_y, bits;
3339                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3340                 const int stride= s->block_wrap[0]*2;
3341
3342 //              do{ //FIXME
3343                 bits= show_bits(&s->gb, 17);
3344                 if(bits==MOTION_MARKER){
3345                     return mb_num-1;
3346                 }
3347                 skip_bits1(&s->gb);
3348                 if(bits&0x10000){
3349                     /* skip mb */
3350                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3351                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3352                         mx= get_amv(s, 0);
3353                         my= get_amv(s, 1);
3354                     }else{
3355                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3356                         mx=my=0;
3357                     }
3358                     mot_val[0       ]= mot_val[2       ]=
3359                     mot_val[0+stride]= mot_val[2+stride]= mx;
3360                     mot_val[1       ]= mot_val[3       ]=
3361                     mot_val[1+stride]= mot_val[3+stride]= my;
3362
3363                     if(s->mbintra_table[xy])
3364                         ff_clean_intra_table_entries(s);
3365                     continue;
3366                 }
3367
3368                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3369                 if (cbpc < 0){
3370                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3371                     return -1;
3372                 }
3373 //              }while(cbpc == 20);
3374
3375                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3376
3377                 s->mb_intra = ((cbpc & 4) != 0);
3378
3379                 if(s->mb_intra){
3380                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3381                     s->mbintra_table[xy]= 1;
3382                     mot_val[0       ]= mot_val[2       ]=
3383                     mot_val[0+stride]= mot_val[2+stride]= 0;
3384                     mot_val[1       ]= mot_val[3       ]=
3385                     mot_val[1+stride]= mot_val[3+stride]= 0;
3386                 }else{
3387                     if(s->mbintra_table[xy])
3388                         ff_clean_intra_table_entries(s);
3389
3390                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3391                         s->mcsel= get_bits1(&s->gb);
3392                     else s->mcsel= 0;
3393
3394                     if ((cbpc & 16) == 0) {
3395                         /* 16x16 motion prediction */
3396
3397                         h263_pred_motion(s, 0, &pred_x, &pred_y);
3398                         if(!s->mcsel){
3399                             mx = h263_decode_motion(s, pred_x, s->f_code);
3400                             if (mx >= 0xffff)
3401                                 return -1;
3402
3403                             my = h263_decode_motion(s, pred_y, s->f_code);
3404                             if (my >= 0xffff)
3405                                 return -1;
3406                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3407                         } else {
3408                             mx = get_amv(s, 0);
3409                             my = get_amv(s, 1);
3410                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3411                         }
3412
3413                         mot_val[0       ]= mot_val[2       ] =
3414                         mot_val[0+stride]= mot_val[2+stride]= mx;
3415                         mot_val[1       ]= mot_val[3       ]=
3416                         mot_val[1+stride]= mot_val[3+stride]= my;
3417                     } else {
3418                         int i;
3419                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3420                         for(i=0;i<4;i++) {
3421                             int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3422                             mx = h263_decode_motion(s, pred_x, s->f_code);
3423                             if (mx >= 0xffff)
3424                                 return -1;
3425
3426                             my = h263_decode_motion(s, pred_y, s->f_code);
3427                             if (my >= 0xffff)
3428                                 return -1;
3429                             mot_val[0] = mx;
3430                             mot_val[1] = my;
3431                         }
3432                     }
3433                 }
3434             }
3435         }
3436         s->mb_x= 0;
3437     }
3438
3439     return mb_num;
3440 }
3441
3442 /**
3443  * decode second partition.
3444  * @return <0 if an error occured
3445  */
3446 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3447     int mb_num=0;
3448     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3449
3450     s->mb_x= s->resync_mb_x;
3451     s->first_slice_line=1;
3452     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3453         ff_init_block_index(s);
3454         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3455             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3456
3457             mb_num++;
3458             ff_update_block_index(s);
3459             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3460                 s->first_slice_line=0;
3461
3462             if(s->pict_type==I_TYPE){
3463                 int ac_pred= get_bits1(&s->gb);
3464                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3465                 if(cbpy<0){
3466                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3467                     return -1;
3468                 }
3469
3470                 s->cbp_table[xy]|= cbpy<<2;
3471                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3472             }else{ /* P || S_TYPE */
3473                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3474                     int dir=0,i;
3475                     int ac_pred = get_bits1(&s->gb);
3476                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3477
3478                     if(cbpy<0){
3479                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3480                         return -1;
3481                     }
3482
3483                     if(s->cbp_table[xy] & 8) {
3484                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3485                     }
3486                     s->current_picture.qscale_table[xy]= s->qscale;
3487
3488                     for(i=0; i<6; i++){
3489                         int dc_pred_dir;
3490                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3491                         if(dc < 0){
3492                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3493                             return -1;
3494                         }
3495                         dir<<=1;
3496                         if(dc_pred_dir) dir|=1;
3497                     }
3498                     s->cbp_table[xy]&= 3; //remove dquant
3499                     s->cbp_table[xy]|= cbpy<<2;
3500                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3501                     s->pred_dir_table[xy]= dir;
3502                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3503                     s->current_picture.qscale_table[xy]= s->qscale;
3504                     s->cbp_table[xy]= 0;
3505                 }else{
3506                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3507
3508                     if(cbpy<0){
3509                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3510                         return -1;
3511                     }
3512
3513                     if(s->cbp_table[xy] & 8) {
3514                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3515                     }
3516                     s->current_picture.qscale_table[xy]= s->qscale;
3517
3518                     s->cbp_table[xy]&= 3; //remove dquant
3519                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3520                 }
3521             }
3522         }
3523         if(mb_num >= mb_count) return 0;
3524         s->mb_x= 0;
3525     }
3526     return 0;
3527 }
3528
3529 /**
3530  * decodes the first & second partition
3531  * @return <0 if error (and sets error type in the error_status_table)
3532  */
3533 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3534 {
3535     int mb_num;
3536     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3537     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3538
3539     mb_num= mpeg4_decode_partition_a(s);
3540     if(mb_num<0){
3541         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3542         return -1;
3543     }
3544
3545     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3546         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3547         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3548         return -1;
3549     }
3550
3551     s->mb_num_left= mb_num;
3552
3553     if(s->pict_type==I_TYPE){
3554         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3555             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3556             return -1;
3557         }
3558     }else{
3559         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3560             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3561             return -1;
3562         }
3563     }
3564     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3565
3566     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3567         if(s->pict_type==P_TYPE)
3568             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3569         return -1;
3570     }else{
3571         if(s->pict_type==P_TYPE)
3572             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3573     }
3574
3575     return 0;
3576 }
3577
3578 /**
3579  * decode partition C of one MB.
3580  * @return <0 if an error occured
3581  */
3582 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3583 {
3584     int cbp, mb_type;
3585     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3586
3587     mb_type= s->current_picture.mb_type[xy];
3588     cbp = s->cbp_table[xy];
3589
3590     if(s->current_picture.qscale_table[xy] != s->qscale){
3591         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3592     }
3593
3594     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3595         int i;
3596         for(i=0; i<4; i++){
3597             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3598             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3599         }
3600         s->mb_intra = IS_INTRA(mb_type);
3601
3602         if (IS_SKIP(mb_type)) {
3603             /* skip mb */
3604             for(i=0;i<6;i++)
3605                 s->block_last_index[i] = -1;
3606             s->mv_dir = MV_DIR_FORWARD;
3607             s->mv_type = MV_TYPE_16X16;
3608             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3609                 s->mcsel=1;
3610                 s->mb_skiped = 0;
3611             }else{
3612                 s->mcsel=0;
3613                 s->mb_skiped = 1;
3614             }
3615         }else if(s->mb_intra){
3616             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3617         }else if(!s->mb_intra){
3618 //            s->mcsel= 0; //FIXME do we need to init that
3619
3620             s->mv_dir = MV_DIR_FORWARD;
3621             if (IS_8X8(mb_type)) {
3622                 s->mv_type = MV_TYPE_8X8;
3623             } else {
3624                 s->mv_type = MV_TYPE_16X16;
3625             }
3626         }
3627     } else { /* I-Frame */
3628         s->mb_intra = 1;
3629         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3630     }
3631
3632     if (!IS_SKIP(mb_type)) {
3633         int i;
3634         /* decode each block */
3635         for (i = 0; i < 6; i++) {
3636             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3637                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3638                 return -1;
3639             }
3640             cbp+=cbp;
3641         }
3642     }
3643
3644     /* per-MB end of slice check */
3645
3646     if(--s->mb_num_left <= 0){
3647 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3648         if(mpeg4_is_resync(s))
3649             return SLICE_END;
3650         else
3651             return SLICE_NOEND;
3652     }else{
3653         if(mpeg4_is_resync(s)){
3654             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3655             if(s->cbp_table[xy+delta])
3656                 return SLICE_END;
3657         }
3658         return SLICE_OK;
3659     }
3660 }
3661
3662 /**
3663  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3664  */
3665 static void preview_obmc(MpegEncContext *s){
3666     GetBitContext gb= s->gb;
3667
3668     int cbpc, i, pred_x, pred_y, mx, my;
3669     int16_t *mot_val;
3670     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3671     const int stride= s->block_wrap[0]*2;
3672
3673     for(i=0; i<4; i++)
3674         s->block_index[i]+= 2;
3675     for(i=4; i<6; i++)
3676         s->block_index[i]+= 1;
3677     s->mb_x++;
3678
3679     assert(s->pict_type == P_TYPE);
3680
3681     do{
3682         if (get_bits1(&s->gb)) {
3683             /* skip mb */
3684             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3685             mot_val[0       ]= mot_val[2       ]=
3686             mot_val[0+stride]= mot_val[2+stride]= 0;
3687             mot_val[1       ]= mot_val[3       ]=
3688             mot_val[1+stride]= mot_val[3+stride]= 0;
3689
3690             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3691             goto end;
3692         }
3693         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3694     }while(cbpc == 20);
3695
3696     if(cbpc & 4){
3697         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3698     }else{
3699         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3700         if (cbpc & 8) {
3701             if(s->modified_quant){
3702                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3703                 else                  skip_bits(&s->gb, 5);
3704             }else
3705                 skip_bits(&s->gb, 2);
3706         }
3707
3708         if ((cbpc & 16) == 0) {
3709                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3710                 /* 16x16 motion prediction */
3711                 mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);
3712                 if (s->umvplus)
3713                    mx = h263p_decode_umotion(s, pred_x);
3714                 else
3715                    mx = h263_decode_motion(s, pred_x, 1);
3716
3717                 if (s->umvplus)
3718                    my = h263p_decode_umotion(s, pred_y);
3719                 else
3720                    my = h263_decode_motion(s, pred_y, 1);
3721
3722                 mot_val[0       ]= mot_val[2       ]=
3723                 mot_val[0+stride]= mot_val[2+stride]= mx;
3724                 mot_val[1       ]= mot_val[3       ]=
3725                 mot_val[1+stride]= mot_val[3+stride]= my;
3726         } else {
3727             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3728             for(i=0;i<4;i++) {
3729                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3730                 if (s->umvplus)
3731                   mx = h263p_decode_umotion(s, pred_x);
3732                 else
3733                   mx = h263_decode_motion(s, pred_x, 1);
3734
3735                 if (s->umvplus)
3736                   my = h263p_decode_umotion(s, pred_y);
3737                 else
3738                   my = h263_decode_motion(s, pred_y, 1);
3739                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3740                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3741                 mot_val[0] = mx;
3742                 mot_val[1] = my;
3743             }
3744         }
3745     }
3746 end:
3747
3748     for(i=0; i<4; i++)
3749         s->block_index[i]-= 2;
3750     for(i=4; i<6; i++)
3751         s->block_index[i]-= 1;
3752     s->mb_x--;
3753
3754     s->gb= gb;
3755 }
3756
3757 static void h263_decode_dquant(MpegEncContext *s){
3758     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3759
3760     if(s->modified_quant){
3761         if(get_bits1(&s->gb))
3762             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3763         else
3764             s->qscale= get_bits(&s->gb, 5);
3765     }else
3766         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3767     ff_set_qscale(s, s->qscale);
3768 }
3769
3770 int ff_h263_decode_mb(MpegEncContext *s,
3771                       DCTELEM block[6][64])
3772 {
3773     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3774     int16_t *mot_val;
3775     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3776
3777     assert(!s->h263_pred);
3778
3779     if (s->pict_type == P_TYPE) {
3780         do{
3781             if (get_bits1(&s->gb)) {
3782                 /* skip mb */
3783                 s->mb_intra = 0;
3784                 for(i=0;i<6;i++)
3785                     s->block_last_index[i] = -1;
3786                 s->mv_dir = MV_DIR_FORWARD;
3787                 s->mv_type = MV_TYPE_16X16;
3788                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3789                 s->mv[0][0][0] = 0;
3790                 s->mv[0][0][1] = 0;
3791                 s->mb_skiped = !(s->obmc | s->loop_filter);
3792                 goto end;
3793             }
3794             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3795             //fprintf(stderr, "\tCBPC: %d", cbpc);
3796             if (cbpc < 0){
3797                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3798                 return -1;
3799             }
3800         }while(cbpc == 20);
3801
3802         dquant = cbpc & 8;
3803         s->mb_intra = ((cbpc & 4) != 0);
3804         if (s->mb_intra) goto intra;
3805
3806         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3807
3808         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3809             cbpy ^= 0xF;
3810
3811         cbp = (cbpc & 3) | (cbpy << 2);
3812         if (dquant) {
3813             h263_decode_dquant(s);
3814         }
3815
3816         s->mv_dir = MV_DIR_FORWARD;
3817         if ((cbpc & 16) == 0) {
3818             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3819             /* 16x16 motion prediction */
3820             s->mv_type = MV_TYPE_16X16;
3821             h263_pred_motion(s, 0, &pred_x, &pred_y);
3822             if (s->umvplus)
3823                mx = h263p_decode_umotion(s, pred_x);
3824             else
3825                mx = h263_decode_motion(s, pred_x, 1);
3826
3827             if (mx >= 0xffff)
3828                 return -1;
3829
3830             if (s->umvplus)
3831                my = h263p_decode_umotion(s, pred_y);
3832             else
3833                my = h263_decode_motion(s, pred_y, 1);
3834
3835             if (my >= 0xffff)
3836                 return -1;
3837             s->mv[0][0][0] = mx;
3838             s->mv[0][0][1] = my;
3839
3840             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3841                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3842         } else {
3843             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3844             s->mv_type = MV_TYPE_8X8;
3845             for(i=0;i<4;i++) {
3846                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3847                 if (s->umvplus)
3848                   mx = h263p_decode_umotion(s, pred_x);
3849                 else
3850                   mx = h263_decode_motion(s, pred_x, 1);
3851                 if (mx >= 0xffff)
3852                     return -1;
3853
3854                 if (s->umvplus)
3855                   my = h263p_decode_umotion(s, pred_y);
3856                 else
3857                   my = h263_decode_motion(s, pred_y, 1);
3858                 if (my >= 0xffff)
3859                     return -1;
3860                 s->mv[0][i][0] = mx;
3861                 s->mv[0][i][1] = my;
3862                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3863                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3864                 mot_val[0] = mx;
3865                 mot_val[1] = my;
3866             }
3867         }
3868
3869         /* decode each block */
3870         for (i = 0; i < 6; i++) {
3871             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3872                 return -1;
3873             cbp+=cbp;
3874         }
3875
3876         if(s->obmc){
3877             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3878                 preview_obmc(s);
3879         }
3880     } else if(s->pict_type==B_TYPE) {
3881         int mb_type;
3882         const int stride= s->b8_stride;
3883         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3884         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3885 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3886
3887         //FIXME ugly
3888         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
3889         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
3890         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
3891         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3892
3893         do{
3894             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3895             if (mb_type < 0){
3896                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3897                 return -1;
3898             }
3899
3900             mb_type= h263_mb_type_b_map[ mb_type ];
3901         }while(!mb_type);
3902
3903         s->mb_intra = IS_INTRA(mb_type);
3904         if(HAS_CBP(mb_type)){
3905             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3906             if(s->mb_intra){
3907                 dquant = IS_QUANT(mb_type);
3908                 goto intra;
3909             }
3910
3911             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3912
3913             if (cbpy < 0){
3914                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3915                 return -1;
3916             }
3917
3918             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3919                 cbpy ^= 0xF;
3920
3921             cbp = (cbpc & 3) | (cbpy << 2);
3922         }else
3923             cbp=0;
3924
3925         assert(!s->mb_intra);
3926
3927         if(IS_QUANT(mb_type)){
3928             h263_decode_dquant(s);
3929         }
3930
3931         if(IS_DIRECT(mb_type)){
3932             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3933             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3934         }else{
3935             s->mv_dir = 0;
3936             s->mv_type= MV_TYPE_16X16;
3937 //FIXME UMV
3938
3939             if(USES_LIST(mb_type, 0)){
3940                 int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my);
3941                 s->mv_dir = MV_DIR_FORWARD;
3942
3943                 mx = h263_decode_motion(s, mx, 1);
3944                 my = h263_decode_motion(s, my, 1);
3945
3946                 s->mv[0][0][0] = mx;
3947                 s->mv[0][0][1] = my;
3948                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3949                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3950             }
3951
3952             if(USES_LIST(mb_type, 1)){
3953                 int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my);
3954                 s->mv_dir |= MV_DIR_BACKWARD;
3955
3956                 mx = h263_decode_motion(s, mx, 1);
3957                 my = h263_decode_motion(s, my, 1);
3958
3959                 s->mv[1][0][0] = mx;
3960                 s->mv[1][0][1] = my;
3961                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3962                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3963             }
3964         }
3965
3966         s->current_picture.mb_type[xy]= mb_type;
3967
3968         /* decode each block */
3969         for (i = 0; i < 6; i++) {
3970             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3971                 return -1;
3972             cbp+=cbp;
3973         }
3974     } else { /* I-Frame */
3975         do{
3976             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3977             if (cbpc < 0){
3978                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3979                 return -1;
3980             }
3981         }while(cbpc == 8);
3982
3983         dquant = cbpc & 4;
3984         s->mb_intra = 1;
3985 intra:
3986         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3987         if (s->h263_aic) {
3988             s->ac_pred = get_bits1(&s->gb);
3989             if(s->ac_pred){
3990                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3991
3992                 s->h263_aic_dir = get_bits1(&s->gb);
3993             }
3994         }else
3995             s->ac_pred = 0;
3996
3997         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3998         if(cbpy<0){
3999             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4000             return -1;
4001         }
4002         cbp = (cbpc & 3) | (cbpy << 2);
4003         if (dquant) {
4004             h263_decode_dquant(s);
4005         }
4006
4007         /* decode each block */
4008         for (i = 0; i < 6; i++) {
4009             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4010                 return -1;
4011             cbp+=cbp;
4012         }
4013     }
4014 end:
4015
4016         /* per-MB end of slice check */
4017     {
4018         int v= show_bits(&s->gb, 16);
4019
4020         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4021             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4022         }
4023
4024         if(v==0)
4025             return SLICE_END;
4026     }
4027
4028     return SLICE_OK;
4029 }
4030
4031 int ff_mpeg4_decode_mb(MpegEncContext *s,
4032                       DCTELEM block[6][64])
4033 {
4034     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4035     int16_t *mot_val;
4036     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4037     const int xy= s->mb_x + s->mb_y * s->mb_stride;
4038
4039     assert(s->h263_pred);
4040
4041     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4042         do{
4043             if (get_bits1(&s->gb)) {
4044                 /* skip mb */
4045                 s->mb_intra = 0;
4046                 for(i=0;i<6;i++)
4047                     s->block_last_index[i] = -1;
4048                 s->mv_dir = MV_DIR_FORWARD;
4049                 s->mv_type = MV_TYPE_16X16;
4050                 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4051                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4052                     s->mcsel=1;
4053                     s->mv[0][0][0]= get_amv(s, 0);
4054                     s->mv[0][0][1]= get_amv(s, 1);
4055
4056                     s->mb_skiped = 0;
4057                 }else{
4058                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4059                     s->mcsel=0;
4060                     s->mv[0][0][0] = 0;
4061                     s->mv[0][0][1] = 0;
4062                     s->mb_skiped = 1;
4063                 }
4064                 goto end;
4065             }
4066             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4067             //fprintf(stderr, "\tCBPC: %d", cbpc);
4068             if (cbpc < 0){
4069                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4070                 return -1;
4071             }
4072         }while(cbpc == 20);
4073
4074         dquant = cbpc & 8;
4075         s->mb_intra = ((cbpc & 4) != 0);
4076         if (s->mb_intra) goto intra;
4077
4078         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4079             s->mcsel= get_bits1(&s->gb);
4080         else s->mcsel= 0;
4081         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4082
4083         cbp = (cbpc & 3) | (cbpy << 2);
4084         if (dquant) {
4085             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4086         }
4087         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4088             s->interlaced_dct= get_bits1(&s->gb);
4089
4090         s->mv_dir = MV_DIR_FORWARD;
4091         if ((cbpc & 16) == 0) {
4092             if(s->mcsel){
4093                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4094                 /* 16x16 global motion prediction */
4095                 s->mv_type = MV_TYPE_16X16;
4096                 mx= get_amv(s, 0);
4097                 my= get_amv(s, 1);
4098                 s->mv[0][0][0] = mx;
4099                 s->mv[0][0][1] = my;
4100             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4101                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4102                 /* 16x8 field motion prediction */
4103                 s->mv_type= MV_TYPE_FIELD;
4104
4105                 s->field_select[0][0]= get_bits1(&s->gb);
4106                 s->field_select[0][1]= get_bits1(&s->gb);
4107
4108                 h263_pred_motion(s, 0, &pred_x, &pred_y);
4109
4110                 for(i=0; i<2; i++){
4111                     mx = h263_decode_motion(s, pred_x, s->f_code);
4112                     if (mx >= 0xffff)
4113                         return -1;
4114
4115                     my = h263_decode_motion(s, pred_y/2, s->f_code);
4116                     if (my >= 0xffff)
4117                         return -1;
4118
4119                     s->mv[0][i][0] = mx;
4120                     s->mv[0][i][1] = my;
4121                 }
4122             }else{
4123                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4124                 /* 16x16 motion prediction */
4125                 s->mv_type = MV_TYPE_16X16;
4126                 h263_pred_motion(s, 0, &pred_x, &pred_y);
4127                 mx = h263_decode_motion(s, pred_x, s->f_code);
4128
4129                 if (mx >= 0xffff)
4130                     return -1;
4131
4132                 my = h263_decode_motion(s, pred_y, s->f_code);
4133
4134                 if (my >= 0xffff)
4135                     return -1;
4136                 s->mv[0][0][0] = mx;
4137                 s->mv[0][0][1] = my;
4138             }
4139         } else {
4140             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4141             s->mv_type = MV_TYPE_8X8;
4142             for(i=0;i<4;i++) {
4143                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
4144                 mx = h263_decode_motion(s, pred_x, s->f_code);
4145                 if (mx >= 0xffff)
4146                     return -1;
4147
4148                 my = h263_decode_motion(s, pred_y, s->f_code);
4149                 if (my >= 0xffff)
4150                     return -1;
4151                 s->mv[0][i][0] = mx;
4152                 s->mv[0][i][1] = my;
4153                 mot_val[0] = mx;
4154                 mot_val[1] = my;
4155             }
4156         }
4157     } else if(s->pict_type==B_TYPE) {
4158         int modb1; // first bit of modb
4159         int modb2; // second bit of modb
4160         int mb_type;
4161
4162         s->mb_intra = 0; //B-frames never contain intra blocks
4163         s->mcsel=0;      //     ...               true gmc blocks
4164
4165         if(s->mb_x==0){
4166             for(i=0; i<2; i++){
4167                 s->last_mv[i][0][0]=
4168                 s->last_mv[i][0][1]=
4169                 s->last_mv[i][1][0]=
4170                 s->last_mv[i][1][1]= 0;
4171             }
4172         }
4173
4174         /* if we skipped it in the future P Frame than skip it now too */
4175         s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4176
4177         if(s->mb_skiped){
4178                 /* skip mb */
4179             for(i=0;i<6;i++)
4180                 s->block_last_index[i] = -1;
4181
4182             s->mv_dir = MV_DIR_FORWARD;
4183             s->mv_type = MV_TYPE_16X16;
4184             s->mv[0][0][0] = 0;
4185             s->mv[0][0][1] = 0;
4186             s->mv[1][0][0] = 0;
4187             s->mv[1][0][1] = 0;
4188             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4189             goto end;
4190         }
4191
4192         modb1= get_bits1(&s->gb);
4193         if(modb1){
4194             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4195             cbp=0;
4196         }else{
4197             modb2= get_bits1(&s->gb);
4198             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4199             if(mb_type<0){
4200                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4201                 return -1;
4202             }
4203             mb_type= mb_type_b_map[ mb_type ];
4204             if(modb2) cbp= 0;
4205             else      cbp= get_bits(&s->gb, 6);
4206
4207             if ((!IS_DIRECT(mb_type)) && cbp) {
4208                 if(get_bits1(&s->gb)){
4209                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4210                 }
4211             }
4212
4213             if(!s->progressive_sequence){
4214                 if(cbp)
4215                     s->interlaced_dct= get_bits1(&s->gb);
4216
4217                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4218                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4219                     mb_type &= ~MB_TYPE_16x16;
4220
4221                     if(USES_LIST(mb_type, 0)){
4222                         s->field_select[0][0]= get_bits1(&s->gb);
4223                         s->field_select[0][1]= get_bits1(&s->gb);
4224                     }
4225                     if(USES_LIST(mb_type, 1)){
4226                         s->field_select[1][0]= get_bits1(&s->gb);
4227                         s->field_select[1][1]= get_bits1(&s->gb);
4228                     }
4229                 }
4230             }
4231
4232             s->mv_dir = 0;
4233             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4234                 s->mv_type= MV_TYPE_16X16;
4235
4236                 if(USES_LIST(mb_type, 0)){
4237                     s->mv_dir = MV_DIR_FORWARD;
4238
4239                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4240                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4241                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4242                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4243                 }
4244
4245                 if(USES_LIST(mb_type, 1)){
4246                     s->mv_dir |= MV_DIR_BACKWARD;
4247
4248                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4249                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4250                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4251                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4252                 }
4253             }else if(!IS_DIRECT(mb_type)){
4254                 s->mv_type= MV_TYPE_FIELD;
4255
4256                 if(USES_LIST(mb_type, 0)){
4257                     s->mv_dir = MV_DIR_FORWARD;
4258
4259                     for(i=0; i<2; i++){
4260                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4261                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4262                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4263                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4264                     }
4265                 }
4266
4267                 if(USES_LIST(mb_type, 1)){
4268                     s->mv_dir |= MV_DIR_BACKWARD;
4269
4270                     for(i=0; i<2; i++){
4271                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4272                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4273                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4274                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4275                     }
4276                 }
4277             }
4278         }
4279
4280         if(IS_DIRECT(mb_type)){
4281             if(IS_SKIP(mb_type))
4282                 mx=my=0;
4283             else{
4284                 mx = h263_decode_motion(s, 0, 1);
4285                 my = h263_decode_motion(s, 0, 1);
4286             }
4287
4288             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4289             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4290         }
4291         s->current_picture.mb_type[xy]= mb_type;
4292     } else { /* I-Frame */
4293         do{
4294             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4295             if (cbpc < 0){
4296                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4297                 return -1;
4298             }
4299         }while(cbpc == 8);
4300
4301         dquant = cbpc & 4;
4302         s->mb_intra = 1;
4303 intra:
4304         s->ac_pred = get_bits1(&s->gb);
4305         if(s->ac_pred)
4306             s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4307         else
4308             s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4309
4310         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4311         if(cbpy<0){
4312             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4313             return -1;
4314         }
4315         cbp = (cbpc & 3) | (cbpy << 2);
4316         if (dquant) {
4317             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4318         }
4319
4320         if(!s->progressive_sequence)
4321             s->interlaced_dct= get_bits1(&s->gb);
4322
4323         /* decode each block */
4324         for (i = 0; i < 6; i++) {
4325             if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4326                 return -1;
4327             cbp+=cbp;
4328         }
4329         goto end;
4330     }
4331
4332     /* decode each block */
4333     for (i = 0; i < 6; i++) {
4334         if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4335             return -1;
4336         cbp+=cbp;
4337     }
4338 end:
4339
4340         /* per-MB end of slice check */
4341     if(s->codec_id==CODEC_ID_MPEG4){
4342         if(mpeg4_is_resync(s)){
4343             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4344             if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4345                 return SLICE_OK;
4346             return SLICE_END;
4347         }
4348     }
4349
4350     return SLICE_OK;
4351 }
4352
4353 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4354 {
4355     int code, val, sign, shift, l;
4356     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4357
4358     if (code == 0)
4359         return pred;
4360     if (code < 0)
4361         return 0xffff;
4362
4363     sign = get_bits1(&s->gb);
4364     shift = f_code - 1;
4365     val = code;
4366     if (shift) {
4367         val = (val - 1) << shift;
4368         val |= get_bits(&s->gb, shift);
4369         val++;
4370     }
4371     if (sign)
4372         val = -val;
4373     val += pred;
4374
4375     /* modulo decoding */
4376     if (!s->h263_long_vectors) {
4377         l = 1 << (f_code + 4);
4378         val = ((val + l)&(l*2-1)) - l;
4379     } else {
4380         /* horrible h263 long vector mode */
4381         if (pred < -31 && val < -63)
4382             val += 64;
4383         if (pred > 32 && val > 63)
4384             val -= 64;
4385
4386     }
4387     return val;
4388 }
4389
4390 /* Decodes RVLC of H.263+ UMV */
4391 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4392 {
4393    int code = 0, sign;
4394
4395    if (get_bits1(&s->gb)) /* Motion difference = 0 */
4396       return pred;
4397
4398    code = 2 + get_bits1(&s->gb);
4399
4400    while (get_bits1(&s->gb))
4401    {
4402       code <<= 1;
4403       code += get_bits1(&s->gb);
4404    }
4405    sign = code & 1;
4406    code >>= 1;
4407
4408    code = (sign) ? (pred - code) : (pred + code);
4409 #ifdef DEBUG
4410    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4411 #endif
4412    return code;
4413
4414 }
4415
4416 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4417                              int n, int coded)
4418 {
4419     int code, level, i, j, last, run;
4420     RLTable *rl = &rl_inter;
4421     const uint8_t *scan_table;
4422     GetBitContext gb= s->gb;
4423
4424     scan_table = s->intra_scantable.permutated;
4425     if (s->h263_aic && s->mb_intra) {
4426         rl = &rl_intra_aic;
4427         i = 0;
4428         if (s->ac_pred) {
4429             if (s->h263_aic_dir)
4430                 scan_table = s->intra_v_scantable.permutated; /* left */
4431             else
4432                 scan_table = s->intra_h_scantable.permutated; /* top */
4433         }
4434     } else if (s->mb_intra) {
4435         /* DC coef */
4436         if(s->codec_id == CODEC_ID_RV10){
4437           if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4438             int component, diff;
4439             component = (n <= 3 ? 0 : n - 4 + 1);
4440             level = s->last_dc[component];
4441             if (s->rv10_first_dc_coded[component]) {
4442                 diff = rv_decode_dc(s, n);
4443                 if (diff == 0xffff)
4444                     return -1;
4445                 level += diff;
4446                 level = level & 0xff; /* handle wrap round */
4447                 s->last_dc[component] = level;
4448             } else {
4449                 s->rv10_first_dc_coded[component] = 1;
4450             }
4451           } else {
4452                 level = get_bits(&s->gb, 8);
4453           }
4454         }else{
4455             level = get_bits(&s->gb, 8);
4456             if((level&0x7F) == 0){
4457                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4458                 if(s->error_resilience >= FF_ER_COMPLIANT)
4459                     return -1;
4460             }
4461             if (level == 255)
4462                 level = 128;
4463         }
4464         block[0] = level;
4465         i = 1;
4466     } else {
4467         i = 0;
4468     }
4469     if (!coded) {
4470         if (s->mb_intra && s->h263_aic)
4471             goto not_coded;
4472         s->block_last_index[n] = i - 1;
4473         return 0;
4474     }
4475 retry:
4476     for(;;) {
4477         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4478         if (code < 0){
4479             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4480             return -1;
4481         }
4482         if (code == rl->n) {
4483             /* escape */
4484             if (s->h263_flv > 1) {
4485                 int is11 = get_bits1(&s->gb);
4486                 last = get_bits1(&s->gb);
4487                 run = get_bits(&s->gb, 6);
4488                 if(is11){
4489                     level = get_sbits(&s->gb, 11);
4490                 } else {
4491                     level = get_sbits(&s->gb, 7);
4492                 }
4493             } else {
4494                 last = get_bits1(&s->gb);
4495                 run = get_bits(&s->gb, 6);
4496                 level = (int8_t)get_bits(&s->gb, 8);
4497                 if(level == -128){
4498                     if (s->codec_id == CODEC_ID_RV10) {
4499                         /* XXX: should patch encoder too */
4500                         level = get_sbits(&s->gb, 12);
4501                     }else{
4502                         level = get_bits(&s->gb, 5);
4503                         level |= get_sbits(&s->gb, 6)<<5;
4504                     }
4505                 }
4506             }
4507         } else {
4508             run = rl->table_run[code];
4509             level = rl->table_level[code];
4510             last = code >= rl->last;
4511             if (get_bits1(&s->gb))
4512                 level = -level;
4513         }
4514         i += run;
4515         if (i >= 64){
4516             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4517                 //looks like a hack but no, its the way its supposed to work ...
4518                 rl = &rl_intra_aic;
4519                 i = 0;
4520                 s->gb= gb;
4521                 memset(block, 0, sizeof(DCTELEM)*64);
4522                 goto retry;
4523             }
4524             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4525             return -1;
4526         }
4527         j = scan_table[i];
4528         block[j] = level;
4529         if (last)
4530             break;
4531         i++;
4532     }
4533 not_coded:
4534     if (s->mb_intra && s->h263_aic) {
4535         h263_pred_acdc(s, block, n);
4536         i = 63;
4537     }
4538     s->block_last_index[n] = i;
4539     return 0;
4540 }
4541
4542 /**
4543  * decodes the dc value.
4544  * @param n block index (0-3 are luma, 4-5 are chroma)
4545  * @param dir_ptr the prediction direction will be stored here
4546  * @return the quantized dc
4547  */
4548 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4549 {
4550     int level, pred, code;
4551     uint16_t *dc_val;
4552
4553     if (n < 4)
4554         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4555     else
4556         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4557     if (code < 0 || code > 9 /* && s->nbit<9 */){
4558         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4559         return -1;
4560     }
4561     if (code == 0) {
4562         level = 0;
4563     } else {
4564         if(IS_3IV1){
4565             if(code==1)
4566                 level= 2*get_bits1(&s->gb)-1;
4567             else{
4568                 if(get_bits1(&s->gb))
4569                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
4570                 else
4571                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4572             }
4573         }else{
4574             level = get_xbits(&s->gb, code);
4575         }
4576
4577         if (code > 8){
4578             if(get_bits1(&s->gb)==0){ /* marker */
4579                 if(s->error_resilience>=2){
4580                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4581                     return -1;
4582                 }
4583             }
4584         }
4585     }
4586     pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4587     level += pred;
4588     if (level < 0){
4589         if(s->error_resilience>=3){
4590             av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4591             return -1;
4592         }
4593         level = 0;
4594     }
4595     if (n < 4) {
4596         *dc_val = level * s->y_dc_scale;
4597     } else {
4598         *dc_val = level * s->c_dc_scale;
4599     }
4600     if(IS_3IV1)
4601         *dc_val = level * 8;
4602
4603     if(s->error_resilience>=3){
4604         if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4605             av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4606             return -1;
4607         }
4608     }
4609     return level;
4610 }
4611
4612 /**
4613  * decodes a block.
4614  * @return <0 if an error occured
4615  */
4616 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4617                               int n, int coded, int intra, int rvlc)
4618 {
4619     int level, i, last, run;
4620     int dc_pred_dir;
4621     RLTable * rl;
4622     RL_VLC_ELEM * rl_vlc;
4623     const uint8_t * scan_table;
4624     int qmul, qadd;
4625
4626     //Note intra & rvlc should be optimized away if this is inlined
4627
4628     if(intra) {
4629       if(s->qscale < s->intra_dc_threshold){
4630         /* DC coef */
4631         if(s->partitioned_frame){
4632             level = s->dc_val[0][ s->block_index[n] ];
4633             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4634             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4635             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4636         }else{
4637             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4638             if (level < 0)
4639                 return -1;
4640         }
4641         block[0] = level;
4642         i = 0;
4643       }else{
4644             i = -1;
4645       }
4646         if (!coded)
4647             goto not_coded;
4648
4649         if(rvlc){
4650             rl = &rvlc_rl_intra;
4651             rl_vlc = rvlc_rl_intra.rl_vlc[0];
4652         }else{
4653             rl = &rl_intra;
4654             rl_vlc = rl_intra.rl_vlc[0];
4655         }
4656         if (s->ac_pred) {
4657             if (dc_pred_dir == 0)
4658                 scan_table = s->intra_v_scantable.permutated; /* left */
4659             else
4660                 scan_table = s->intra_h_scantable.permutated; /* top */
4661         } else {
4662             scan_table = s->intra_scantable.permutated;
4663         }
4664         qmul=1;
4665         qadd=0;
4666     } else {
4667         i = -1;
4668         if (!coded) {
4669             s->block_last_index[n] = i;
4670             return 0;
4671         }
4672         if(rvlc) rl = &rvlc_rl_inter;
4673         else     rl = &rl_inter;
4674
4675         scan_table = s->intra_scantable.permutated;
4676
4677         if(s->mpeg_quant){
4678             qmul=1;
4679             qadd=0;
4680             if(rvlc){
4681                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4682             }else{
4683                 rl_vlc = rl_inter.rl_vlc[0];
4684             }
4685         }else{
4686             qmul = s->qscale << 1;
4687             qadd = (s->qscale - 1) | 1;
4688             if(rvlc){
4689                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4690             }else{
4691                 rl_vlc = rl_inter.rl_vlc[s->qscale];
4692             }
4693         }
4694     }
4695   {
4696     OPEN_READER(re, &s->gb);
4697     for(;;) {
4698         UPDATE_CACHE(re, &s->gb);
4699         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4700         if (level==0) {
4701           /* escape */
4702           if(rvlc){
4703                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4704                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4705                     return -1;
4706                 }; SKIP_CACHE(re, &s->gb, 1);
4707
4708                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4709                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4710                 SKIP_COUNTER(re, &s->gb, 1+1+6);
4711                 UPDATE_CACHE(re, &s->gb);
4712
4713                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4714                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4715                     return -1;
4716                 }; SKIP_CACHE(re, &s->gb, 1);
4717
4718                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4719
4720                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4721                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4722                     return -1;
4723                 }; SKIP_CACHE(re, &s->gb, 5);
4724
4725                 level=  level * qmul + qadd;
4726                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4727                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4728
4729                 i+= run + 1;
4730                 if(last) i+=192;
4731           }else{
4732             int cache;
4733             cache= GET_CACHE(re, &s->gb);
4734
4735             if(IS_3IV1)
4736                 cache ^= 0xC0000000;
4737
4738             if (cache&0x80000000) {
4739                 if (cache&0x40000000) {
4740                     /* third escape */
4741                     SKIP_CACHE(re, &s->gb, 2);
4742                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4743                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4744                     SKIP_COUNTER(re, &s->gb, 2+1+6);
4745                     UPDATE_CACHE(re, &s->gb);
4746
4747                     if(IS_3IV1){
4748                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4749                     }else{
4750                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4751                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4752                             return -1;
4753                         }; SKIP_CACHE(re, &s->gb, 1);
4754
4755                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4756
4757                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4758                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4759                             return -1;
4760                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
4761
4762                         SKIP_COUNTER(re, &s->gb, 1+12+1);
4763                     }
4764
4765                     if(level*s->qscale>1024 || level*s->qscale<-1024){
4766                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4767                         return -1;
4768                     }
4769 #if 0
4770                     if(s->error_resilience >= FF_ER_COMPLIANT){
4771                         const int abs_level= ABS(level);
4772                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4773                             const int run1= run - rl->max_run[last][abs_level] - 1;
4774                             if(abs_level <= rl->max_level[last][run]){
4775                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4776                                 return -1;
4777                             }
4778                             if(s->error_resilience > FF_ER_COMPLIANT){
4779                                 if(abs_level <= rl->max_level[last][run]*2){
4780                                     fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4781                                     return -1;
4782                                 }
4783                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4784                                     fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4785                                     return -1;
4786                                 }
4787                             }
4788                         }
4789                     }
4790 #endif
4791                     if (level>0) level= level * qmul + qadd;
4792                     else         level= level * qmul - qadd;
4793
4794                     i+= run + 1;
4795                     if(last) i+=192;
4796                 } else {
4797                     /* second escape */
4798 #if MIN_CACHE_BITS < 20
4799                     LAST_SKIP_BITS(re, &s->gb, 2);
4800                     UPDATE_CACHE(re, &s->gb);
4801 #else
4802                     SKIP_BITS(re, &s->gb, 2);
4803 #endif
4804                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4805                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4806                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4807                     LAST_SKIP_BITS(re, &s->gb, 1);
4808                 }
4809             } else {
4810                 /* first escape */
4811 #if MIN_CACHE_BITS < 19
4812                 LAST_SKIP_BITS(re, &s->gb, 1);
4813                 UPDATE_CACHE(re, &s->gb);
4814 #else
4815                 SKIP_BITS(re, &s->gb, 1);
4816 #endif
4817                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4818                 i+= run;
4819                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4820                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4821                 LAST_SKIP_BITS(re, &s->gb, 1);
4822             }
4823           }
4824         } else {
4825             i+= run;
4826             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4827             LAST_SKIP_BITS(re, &s->gb, 1);
4828         }
4829         if (i > 62){
4830             i-= 192;
4831             if(i&(~63)){
4832                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4833                 return -1;
4834             }
4835
4836             block[scan_table[i]] = level;
4837             break;
4838         }
4839
4840         block[scan_table[i]] = level;
4841     }
4842     CLOSE_READER(re, &s->gb);
4843   }
4844  not_coded:
4845     if (intra) {
4846         if(s->qscale >= s->intra_dc_threshold){
4847             uint16_t *dc_val;
4848             block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir);
4849             if (n < 4) {
4850                 *dc_val = block[0] * s->y_dc_scale;
4851             } else {
4852                 *dc_val = block[0] * s->c_dc_scale;
4853             }
4854
4855             if(i == -1) i=0;
4856         }
4857
4858         mpeg4_pred_ac(s, block, n, dc_pred_dir);
4859         if (s->ac_pred) {
4860             i = 63; /* XXX: not optimal */
4861         }
4862     }
4863     s->block_last_index[n] = i;
4864     return 0;
4865 }
4866
4867 /* most is hardcoded. should extend to handle all h263 streams */
4868 int h263_decode_picture_header(MpegEncContext *s)
4869 {
4870     int format, width, height, i;
4871     uint32_t startcode;
4872
4873     align_get_bits(&s->gb);
4874
4875     startcode= get_bits(&s->gb, 22-8);
4876
4877     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4878         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4879
4880         if(startcode == 0x20)
4881             break;
4882     }
4883
4884     if (startcode != 0x20) {
4885         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
4886         return -1;
4887     }
4888     /* temporal reference */
4889     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4890
4891     /* PTYPE starts here */
4892     if (get_bits1(&s->gb) != 1) {
4893         /* marker */
4894         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
4895         return -1;
4896     }
4897     if (get_bits1(&s->gb) != 0) {
4898         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
4899         return -1;      /* h263 id */
4900     }
4901     skip_bits1(&s->gb); /* split screen off */
4902     skip_bits1(&s->gb); /* camera  off */
4903     skip_bits1(&s->gb); /* freeze picture release off */
4904
4905     format = get_bits(&s->gb, 3);
4906     /*
4907         0    forbidden
4908         1    sub-QCIF
4909         10   QCIF
4910         7       extended PTYPE (PLUSPTYPE)
4911     */
4912
4913     if (format != 7 && format != 6) {
4914         s->h263_plus = 0;
4915         /* H.263v1 */
4916         width = h263_format[format][0];
4917         height = h263_format[format][1];
4918         if (!width)
4919             return -1;
4920
4921         s->pict_type = I_TYPE + get_bits1(&s->gb);
4922
4923         s->h263_long_vectors = get_bits1(&s->gb);
4924
4925         if (get_bits1(&s->gb) != 0) {
4926             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
4927             return -1;  /* SAC: off */
4928         }
4929         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4930         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
4931
4932         if (get_bits1(&s->gb) != 0) {
4933             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
4934             return -1;  /* not PB frame */
4935         }
4936         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
4937         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
4938
4939         s->width = width;
4940         s->height = height;
4941     } else {
4942         int ufep;
4943
4944         /* H.263v2 */
4945         s->h263_plus = 1;
4946         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4947
4948         /* ufep other than 0 and 1 are reserved */
4949         if (ufep == 1) {
4950             /* OPPTYPE */
4951             format = get_bits(&s->gb, 3);
4952             dprintf("ufep=1, format: %d\n", format);
4953             skip_bits(&s->gb,1); /* Custom PCF */
4954             s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4955             if (get_bits1(&s->gb) != 0) {
4956                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
4957             }
4958             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4959             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
4960             s->loop_filter= get_bits1(&s->gb);
4961             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
4962
4963             s->h263_slice_structured= get_bits1(&s->gb);
4964             if (get_bits1(&s->gb) != 0) {
4965                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
4966             }
4967             if (get_bits1(&s->gb) != 0) {
4968                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
4969             }
4970             s->alt_inter_vlc= get_bits1(&s->gb);
4971             s->modified_quant= get_bits1(&s->gb);
4972             if(s->modified_quant)
4973                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
4974
4975             skip_bits(&s->gb, 1); /* Prevent start code emulation */
4976
4977             skip_bits(&s->gb, 3); /* Reserved */
4978         } else if (ufep != 0) {
4979             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
4980             return -1;
4981         }
4982
4983         /* MPPTYPE */
4984         s->pict_type = get_bits(&s->gb, 3);
4985         switch(s->pict_type){
4986         case 0: s->pict_type= I_TYPE;break;
4987         case 1: s->pict_type= P_TYPE;break;
4988         case 3: s->pict_type= B_TYPE;break;
4989         case 7: s->pict_type= I_TYPE;break; //ZYGO
4990         default:
4991             return -1;
4992         }
4993         skip_bits(&s->gb, 2);
4994         s->no_rounding = get_bits1(&s->gb);
4995         skip_bits(&s->gb, 4);
4996
4997         /* Get the picture dimensions */
4998         if (ufep) {
4999             if (format == 6) {
5000                 /* Custom Picture Format (CPFMT) */
5001                 s->aspect_ratio_info = get_bits(&s->gb, 4);
5002                 dprintf("aspect: %d\n", s->aspect_ratio_info);
5003                 /* aspect ratios:
5004                 0 - forbidden
5005                 1 - 1:1
5006                 2 - 12:11 (CIF 4:3)
5007                 3 - 10:11 (525-type 4:3)
5008                 4 - 16:11 (CIF 16:9)
5009                 5 - 40:33 (525-type 16:9)
5010                 6-14 - reserved
5011                 */
5012                 width = (get_bits(&s->gb, 9) + 1) * 4;
5013                 skip_bits1(&s->gb);
5014                 height = get_bits(&s->gb, 9) * 4;
5015                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5016                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5017                     /* aspected dimensions */
5018                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5019                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5020                 }else{
5021                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5022                 }
5023             } else {
5024                 width = h263_format[format][0];
5025                 height = h263_format[format][1];
5026             }
5027             if ((width == 0) || (height == 0))
5028                 return -1;
5029             s->width = width;
5030             s->height = height;
5031             if (s->umvplus) {
5032                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5033                     skip_bits1(&s->gb);
5034             }
5035             if(s->h263_slice_structured){
5036                 if (get_bits1(&s->gb) != 0) {
5037                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5038                 }
5039                 if (get_bits1(&s->gb) != 0) {
5040                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5041                 }
5042             }
5043         }
5044
5045         s->qscale = get_bits(&s->gb, 5);
5046     }
5047
5048     /* PEI */
5049     while (get_bits1(&s->gb) != 0) {
5050         skip_bits(&s->gb, 8);
5051     }
5052
5053     if(s->h263_slice_structured){
5054         if (get_bits1(&s->gb) != 1) {
5055             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5056             return -1;
5057         }
5058
5059         ff_h263_decode_mba(s);
5060
5061         if (get_bits1(&s->gb) != 1) {
5062             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5063             return -1;
5064         }
5065     }
5066     s->f_code = 1;
5067
5068     if(s->h263_aic){
5069          s->y_dc_scale_table=
5070          s->c_dc_scale_table= ff_aic_dc_scale_table;
5071     }else{
5072         s->y_dc_scale_table=
5073         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5074     }
5075
5076      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5077          av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s\n",
5078          s->qscale, av_get_pict_type_char(s->pict_type),
5079          s->gb.size_in_bits, 1-s->no_rounding,
5080          s->obmc ? " AP" : "",
5081          s->umvplus ? " UMV" : "",
5082          s->h263_long_vectors ? " LONG" : "",
5083          s->h263_plus ? " +" : "",
5084          s->h263_aic ? " AIC" : "",
5085          s->alt_inter_vlc ? " AIV" : "",
5086          s->modified_quant ? " MQ" : "",
5087          s->loop_filter ? " LOOP" : "",
5088          s->h263_slice_structured ? " SS" : ""
5089          );
5090      }
5091 #if 1
5092     if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5093         int i,j;
5094         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5095         av_log(s->avctx, AV_LOG_DEBUG, "\n");
5096         for(i=0; i<13; i++){
5097             for(j=0; j<3; j++){
5098                 int v= get_bits(&s->gb, 8);
5099                 v |= get_sbits(&s->gb, 8)<<8;
5100                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5101             }
5102             av_log(s->avctx, AV_LOG_DEBUG, "\n");
5103         }
5104         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5105     }
5106 #endif
5107
5108     return 0;
5109 }
5110
5111 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
5112 {
5113     int i;
5114     int a= 2<<s->sprite_warping_accuracy;
5115     int rho= 3-s->sprite_warping_accuracy;
5116     int r=16/a;
5117     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5118     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5119     int sprite_ref[4][2];
5120     int virtual_ref[2][2];
5121     int w2, h2, w3, h3;
5122     int alpha=0, beta=0;
5123     int w= s->width;
5124     int h= s->height;
5125     int min_ab;
5126
5127     for(i=0; i<s->num_sprite_warping_points; i++){
5128         int length;
5129         int x=0, y=0;
5130
5131         length= get_vlc(&s->gb, &sprite_trajectory);
5132         if(length){
5133             x= get_xbits(&s->gb, length);
5134         }
5135         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
5136
5137         length= get_vlc(&s->gb, &sprite_trajectory);
5138         if(length){
5139             y=get_xbits(&s->gb, length);
5140         }
5141         skip_bits1(&s->gb); /* marker bit */
5142 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5143         d[i][0]= x;
5144         d[i][1]= y;
5145     }
5146
5147     while((1<<alpha)<w) alpha++;
5148     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5149     w2= 1<<alpha;
5150     h2= 1<<beta;
5151
5152 // Note, the 4th point isnt used for GMC
5153     if(s->divx_version==500 && s->divx_build==413){
5154         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5155         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5156         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5157         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5158         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5159         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5160     } else {
5161         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5162         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5163         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5164         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5165         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5166         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5167     }
5168 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5169     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5170
5171 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5172 // perhaps it should be reordered to be more readable ...
5173 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5174 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5175     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5176         + 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);
5177     virtual_ref[0][1]= 16*vop_ref[0][1]
5178         + 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);
5179     virtual_ref[1][0]= 16*vop_ref[0][0]
5180         + 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);
5181     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5182         + 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);
5183
5184     switch(s->num_sprite_warping_points)
5185     {
5186         case 0:
5187             s->sprite_offset[0][0]= 0;
5188             s->sprite_offset[0][1]= 0;
5189             s->sprite_offset[1][0]= 0;
5190             s->sprite_offset[1][1]= 0;
5191             s->sprite_delta[0][0]= a;
5192             s->sprite_delta[0][1]= 0;
5193             s->sprite_delta[1][0]= 0;
5194             s->sprite_delta[1][1]= a;
5195             s->sprite_shift[0]= 0;
5196             s->sprite_shift[1]= 0;
5197             break;
5198         case 1: //GMC only
5199             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5200             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5201             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5202             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5203             s->sprite_delta[0][0]= a;
5204             s->sprite_delta[0][1]= 0;
5205             s->sprite_delta[1][0]= 0;
5206             s->sprite_delta[1][1]= a;
5207             s->sprite_shift[0]= 0;
5208             s->sprite_shift[1]= 0;
5209             break;
5210         case 2:
5211             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5212                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5213                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5214                                                   + (1<<(alpha+rho-1));
5215             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5216                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5217                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5218                                                   + (1<<(alpha+rho-1));
5219             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5220                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5221                                      +2*w2*r*sprite_ref[0][0]
5222                                      - 16*w2
5223                                      + (1<<(alpha+rho+1)));
5224             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5225                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5226                                      +2*w2*r*sprite_ref[0][1]
5227                                      - 16*w2
5228                                      + (1<<(alpha+rho+1)));
5229             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5230             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5231             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5232             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5233
5234             s->sprite_shift[0]= alpha+rho;
5235             s->sprite_shift[1]= alpha+rho+2;
5236             break;
5237         case 3:
5238             min_ab= FFMIN(alpha, beta);
5239             w3= w2>>min_ab;
5240             h3= h2>>min_ab;
5241             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5242                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5243                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5244                                    + (1<<(alpha+beta+rho-min_ab-1));
5245             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5246                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5247                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5248                                    + (1<<(alpha+beta+rho-min_ab-1));
5249             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5250                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5251                                    + 2*w2*h3*r*sprite_ref[0][0]
5252                                    - 16*w2*h3
5253                                    + (1<<(alpha+beta+rho-min_ab+1));
5254             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5255                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5256                                    + 2*w2*h3*r*sprite_ref[0][1]
5257                                    - 16*w2*h3
5258                                    + (1<<(alpha+beta+rho-min_ab+1));
5259             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5260             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5261             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5262             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5263
5264             s->sprite_shift[0]= alpha + beta + rho - min_ab;
5265             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5266             break;
5267     }
5268     /* try to simplify the situation */
5269     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5270        && s->sprite_delta[0][1] == 0
5271        && s->sprite_delta[1][0] == 0
5272        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5273     {
5274         s->sprite_offset[0][0]>>=s->sprite_shift[0];
5275         s->sprite_offset[0][1]>>=s->sprite_shift[0];
5276         s->sprite_offset[1][0]>>=s->sprite_shift[1];
5277         s->sprite_offset[1][1]>>=s->sprite_shift[1];
5278         s->sprite_delta[0][0]= a;
5279         s->sprite_delta[0][1]= 0;
5280         s->sprite_delta[1][0]= 0;
5281         s->sprite_delta[1][1]= a;
5282         s->sprite_shift[0]= 0;
5283         s->sprite_shift[1]= 0;
5284         s->real_sprite_warping_points=1;
5285     }
5286     else{
5287         int shift_y= 16 - s->sprite_shift[0];
5288         int shift_c= 16 - s->sprite_shift[1];
5289 //printf("shifts %d %d\n", shift_y, shift_c);
5290         for(i=0; i<2; i++){
5291             s->sprite_offset[0][i]<<= shift_y;
5292             s->sprite_offset[1][i]<<= shift_c;
5293             s->sprite_delta[0][i]<<= shift_y;
5294             s->sprite_delta[1][i]<<= shift_y;
5295             s->sprite_shift[i]= 16;
5296         }
5297         s->real_sprite_warping_points= s->num_sprite_warping_points;
5298     }
5299 #if 0
5300 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5301     vop_ref[0][0], vop_ref[0][1],
5302     vop_ref[1][0], vop_ref[1][1],
5303     vop_ref[2][0], vop_ref[2][1],
5304     sprite_ref[0][0], sprite_ref[0][1],
5305     sprite_ref[1][0], sprite_ref[1][1],
5306     sprite_ref[2][0], sprite_ref[2][1],
5307     virtual_ref[0][0], virtual_ref[0][1],
5308     virtual_ref[1][0], virtual_ref[1][1]
5309     );
5310
5311 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5312     s->sprite_offset[0][0], s->sprite_offset[0][1],
5313     s->sprite_delta[0][0], s->sprite_delta[0][1],
5314     s->sprite_delta[1][0], s->sprite_delta[1][1],
5315     s->sprite_shift[0]
5316     );
5317 #endif
5318 }
5319
5320 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5321     int hours, minutes, seconds;
5322
5323     hours= get_bits(gb, 5);
5324     minutes= get_bits(gb, 6);
5325     skip_bits1(gb);
5326     seconds= get_bits(gb, 6);
5327
5328     s->time_base= seconds + 60*(minutes + 60*hours);
5329
5330     skip_bits1(gb);
5331     skip_bits1(gb);
5332
5333     return 0;
5334 }
5335
5336 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5337     int width, height, vo_ver_id;
5338
5339     /* vol header */
5340     skip_bits(gb, 1); /* random access */
5341     s->vo_type= get_bits(gb, 8);
5342     if (get_bits1(gb) != 0) { /* is_ol_id */
5343         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5344         skip_bits(gb, 3); /* vo_priority */
5345     } else {
5346         vo_ver_id = 1;
5347     }
5348 //printf("vo type:%d\n",s->vo_type);
5349     s->aspect_ratio_info= get_bits(gb, 4);
5350     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5351         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5352         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5353     }else{
5354         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5355     }
5356
5357     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5358         int chroma_format= get_bits(gb, 2);
5359         if(chroma_format!=1){
5360             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5361         }
5362         s->low_delay= get_bits1(gb);
5363         if(get_bits1(gb)){ /* vbv parameters */
5364             get_bits(gb, 15);   /* first_half_bitrate */
5365             skip_bits1(gb);     /* marker */
5366             get_bits(gb, 15);   /* latter_half_bitrate */
5367             skip_bits1(gb);     /* marker */
5368             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
5369             skip_bits1(gb);     /* marker */
5370             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
5371             get_bits(gb, 11);   /* first_half_vbv_occupancy */
5372             skip_bits1(gb);     /* marker */
5373             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
5374             skip_bits1(gb);     /* marker */
5375         }
5376     }else{
5377         // set low delay flag only once so the smart? low delay detection wont be overriden
5378         if(s->picture_number==0)
5379             s->low_delay=0;
5380     }
5381
5382     s->shape = get_bits(gb, 2); /* vol shape */
5383     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5384     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5385         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5386         skip_bits(gb, 4);  //video_object_layer_shape_extension
5387     }
5388
5389     check_marker(gb, "before time_increment_resolution");
5390
5391     s->time_increment_resolution = get_bits(gb, 16);
5392
5393     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
5394     if (s->time_increment_bits < 1)
5395         s->time_increment_bits = 1;
5396
5397     check_marker(gb, "before fixed_vop_rate");
5398
5399     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
5400         skip_bits(gb, s->time_increment_bits);
5401     }
5402
5403     if (s->shape != BIN_ONLY_SHAPE) {
5404         if (s->shape == RECT_SHAPE) {
5405             skip_bits1(gb);   /* marker */
5406             width = get_bits(gb, 13);
5407             skip_bits1(gb);   /* marker */
5408             height = get_bits(gb, 13);
5409             skip_bits1(gb);   /* marker */
5410             if(width && height){ /* they should be non zero but who knows ... */
5411                 s->width = width;
5412                 s->height = height;
5413 //                printf("width/height: %d %d\n", width, height);
5414             }
5415         }
5416
5417         s->progressive_sequence=
5418         s->progressive_frame= get_bits1(gb)^1;
5419         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5420             av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
5421         if (vo_ver_id == 1) {
5422             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5423         } else {
5424             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5425         }
5426         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5427         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5428             if(s->vol_sprite_usage==STATIC_SPRITE){
5429                 s->sprite_width = get_bits(gb, 13);
5430                 skip_bits1(gb); /* marker */
5431                 s->sprite_height= get_bits(gb, 13);
5432                 skip_bits1(gb); /* marker */
5433                 s->sprite_left  = get_bits(gb, 13);
5434                 skip_bits1(gb); /* marker */
5435                 s->sprite_top   = get_bits(gb, 13);
5436                 skip_bits1(gb); /* marker */
5437             }
5438             s->num_sprite_warping_points= get_bits(gb, 6);
5439             s->sprite_warping_accuracy = get_bits(gb, 2);
5440             s->sprite_brightness_change= get_bits1(gb);
5441             if(s->vol_sprite_usage==STATIC_SPRITE)
5442                 s->low_latency_sprite= get_bits1(gb);
5443         }
5444         // FIXME sadct disable bit if verid!=1 && shape not rect
5445
5446         if (get_bits1(gb) == 1) {   /* not_8_bit */
5447             s->quant_precision = get_bits(gb, 4); /* quant_precision */
5448             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5449             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %d\n", s->quant_precision);
5450         } else {
5451             s->quant_precision = 5;
5452         }
5453
5454         // FIXME a bunch of grayscale shape things
5455
5456         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5457             int i, v;
5458
5459             /* load default matrixes */
5460             for(i=0; i<64; i++){
5461                 int j= s->dsp.idct_permutation[i];
5462                 v= ff_mpeg4_default_intra_matrix[i];
5463                 s->intra_matrix[j]= v;
5464                 s->chroma_intra_matrix[j]= v;
5465
5466                 v= ff_mpeg4_default_non_intra_matrix[i];
5467                 s->inter_matrix[j]= v;
5468                 s->chroma_inter_matrix[j]= v;
5469             }
5470
5471             /* load custom intra matrix */
5472             if(get_bits1(gb)){
5473                 int last=0;
5474                 for(i=0; i<64; i++){
5475                     int j;
5476                     v= get_bits(gb, 8);
5477                     if(v==0) break;
5478
5479                     last= v;
5480                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5481                     s->intra_matrix[j]= v;
5482                     s->chroma_intra_matrix[j]= v;
5483                 }
5484
5485                 /* replicate last value */
5486                 for(; i<64; i++){
5487                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5488                     s->intra_matrix[j]= last;
5489                     s->chroma_intra_matrix[j]= last;
5490                 }
5491             }
5492
5493             /* load custom non intra matrix */
5494             if(get_bits1(gb)){
5495                 int last=0;
5496                 for(i=0; i<64; i++){
5497                     int j;
5498                     v= get_bits(gb, 8);
5499                     if(v==0) break;
5500
5501                     last= v;
5502                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5503                     s->inter_matrix[j]= v;
5504                     s->chroma_inter_matrix[j]= v;
5505                 }
5506
5507                 /* replicate last value */
5508                 for(; i<64; i++){
5509                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5510                     s->inter_matrix[j]= last;
5511                     s->chroma_inter_matrix[j]= last;
5512                 }
5513             }
5514
5515             // FIXME a bunch of grayscale shape things
5516         }
5517
5518         if(vo_ver_id != 1)
5519              s->quarter_sample= get_bits1(gb);
5520         else s->quarter_sample=0;
5521
5522         if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5523
5524         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5525
5526         s->data_partitioning= get_bits1(gb);
5527         if(s->data_partitioning){
5528             s->rvlc= get_bits1(gb);
5529         }
5530
5531         if(vo_ver_id != 1) {
5532             s->new_pred= get_bits1(gb);
5533             if(s->new_pred){
5534                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5535                 skip_bits(gb, 2); /* requested upstream message type */
5536                 skip_bits1(gb); /* newpred segment type */
5537             }
5538             s->reduced_res_vop= get_bits1(gb);
5539             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5540         }
5541         else{
5542             s->new_pred=0;
5543             s->reduced_res_vop= 0;
5544         }
5545
5546         s->scalability= get_bits1(gb);
5547
5548         if (s->scalability) {
5549             GetBitContext bak= *gb;
5550             int ref_layer_id;
5551             int ref_layer_sampling_dir;
5552             int h_sampling_factor_n;
5553             int h_sampling_factor_m;
5554             int v_sampling_factor_n;
5555             int v_sampling_factor_m;
5556
5557             s->hierachy_type= get_bits1(gb);
5558             ref_layer_id= get_bits(gb, 4);
5559             ref_layer_sampling_dir= get_bits1(gb);
5560             h_sampling_factor_n= get_bits(gb, 5);
5561             h_sampling_factor_m= get_bits(gb, 5);
5562             v_sampling_factor_n= get_bits(gb, 5);
5563             v_sampling_factor_m= get_bits(gb, 5);
5564             s->enhancement_type= get_bits1(gb);
5565
5566             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
5567                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5568
5569 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5570                 s->scalability=0;
5571
5572                 *gb= bak;
5573             }else
5574                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5575
5576             // bin shape stuff FIXME
5577         }
5578     }
5579     return 0;
5580 }
5581
5582 /**
5583  * decodes the user data stuff in the header.
5584  * allso inits divx/xvid/lavc_version/build
5585  */
5586 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5587     char buf[256];
5588     int i;
5589     int e;
5590     int ver, build, ver2, ver3;
5591     char last;
5592
5593     buf[0]= show_bits(gb, 8);
5594     for(i=1; i<256; i++){
5595         buf[i]= show_bits(gb, 16)&0xFF;
5596         if(buf[i]==0) break;
5597         skip_bits(gb, 8);
5598     }
5599     buf[255]=0;
5600
5601     /* divx detection */
5602     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5603     if(e<2)
5604         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5605     if(e>=2){
5606         s->divx_version= ver;
5607         s->divx_build= build;
5608         s->divx_packed= e==3 && last=='p';
5609     }
5610
5611     /* ffmpeg detection */
5612     e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
5613     if(e!=4)
5614         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5615     if(e!=4){
5616         if(strcmp(buf, "ffmpeg")==0){
5617             s->ffmpeg_version= 0x000406;
5618             s->lavc_build= 4600;
5619         }
5620     }
5621     if(e==4){
5622         s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
5623         s->lavc_build= build;
5624     }
5625
5626     /* xvid detection */
5627     e=sscanf(buf, "XviD%d", &build);
5628     if(e==1){
5629         s->xvid_build= build;
5630     }
5631
5632 //printf("User Data: %s\n", buf);
5633     return 0;
5634 }
5635
5636 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5637     int time_incr, time_increment;
5638
5639     s->pict_type = get_bits(gb, 2) + I_TYPE;    /* pict type: I = 0 , P = 1 */
5640     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5641         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n");
5642         s->low_delay=0;
5643     }
5644
5645     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5646     if(s->partitioned_frame)
5647         s->decode_mb= mpeg4_decode_partitioned_mb;
5648     else
5649         s->decode_mb= ff_mpeg4_decode_mb;
5650
5651     if(s->time_increment_resolution==0){
5652         s->time_increment_resolution=1;
5653 //        fprintf(stderr, "time_increment_resolution is illegal\n");
5654     }
5655     time_incr=0;
5656     while (get_bits1(gb) != 0)
5657         time_incr++;
5658
5659     check_marker(gb, "before time_increment");
5660
5661     if(s->time_increment_bits==0){
5662         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
5663
5664         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5665             if(show_bits(gb, s->time_increment_bits+1)&1) break;
5666         }
5667
5668         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5669     }
5670
5671     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5672     else time_increment= get_bits(gb, s->time_increment_bits);
5673
5674 //    printf("%d %X\n", s->time_increment_bits, time_increment);
5675 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
5676     if(s->pict_type!=B_TYPE){
5677         s->last_time_base= s->time_base;
5678         s->time_base+= time_incr;
5679         s->time= s->time_base*s->time_increment_resolution + time_increment;
5680         if(s->workaround_bugs&FF_BUG_UMP4){
5681             if(s->time < s->last_non_b_time){
5682 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5683                 s->time_base++;
5684                 s->time+= s->time_increment_resolution;
5685             }
5686         }
5687         s->pp_time= s->time - s->last_non_b_time;
5688         s->last_non_b_time= s->time;
5689     }else{
5690         s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
5691         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5692         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5693 //            printf("messed up order, seeking?, skiping current b frame\n");
5694             return FRAME_SKIPED;
5695         }
5696
5697         if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
5698         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5699 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
5700         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5701                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5702         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
5703                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5704     }
5705
5706     s->current_picture_ptr->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
5707     if(s->avctx->debug&FF_DEBUG_PTS)
5708         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(1000.0*1000.0));
5709
5710     check_marker(gb, "before vop_coded");
5711
5712     /* vop coded */
5713     if (get_bits1(gb) != 1){
5714         av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5715         return FRAME_SKIPED;
5716     }
5717 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
5718 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5719     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5720                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5721         /* rounding type for motion estimation */
5722         s->no_rounding = get_bits1(gb);
5723     } else {
5724         s->no_rounding = 0;
5725     }
5726 //FIXME reduced res stuff
5727
5728      if (s->shape != RECT_SHAPE) {
5729          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5730              int width, height, hor_spat_ref, ver_spat_ref;
5731
5732              width = get_bits(gb, 13);
5733              skip_bits1(gb);   /* marker */
5734              height = get_bits(gb, 13);
5735              skip_bits1(gb);   /* marker */
5736              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5737              skip_bits1(gb);   /* marker */
5738              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5739          }
5740          skip_bits1(gb); /* change_CR_disable */
5741
5742          if (get_bits1(gb) != 0) {
5743              skip_bits(gb, 8); /* constant_alpha_value */
5744          }
5745      }
5746 //FIXME complexity estimation stuff
5747
5748      if (s->shape != BIN_ONLY_SHAPE) {
5749          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5750          if(!s->progressive_sequence){
5751              s->top_field_first= get_bits1(gb);
5752              s->alternate_scan= get_bits1(gb);
5753          }else
5754              s->alternate_scan= 0;
5755      }
5756
5757      if(s->alternate_scan){
5758          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
5759          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
5760          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5761          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5762      } else{
5763          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
5764          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
5765          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5766          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5767      }
5768
5769      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5770          mpeg4_decode_sprite_trajectory(s);
5771          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5772          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5773      }
5774
5775      if (s->shape != BIN_ONLY_SHAPE) {
5776          s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5777          if(s->qscale==0){
5778              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5779              return -1; // makes no sense to continue, as there is nothing left from the image then
5780          }
5781
5782          if (s->pict_type != I_TYPE) {
5783              s->f_code = get_bits(gb, 3);       /* fcode_for */
5784              if(s->f_code==0){
5785                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5786                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
5787              }
5788          }else
5789              s->f_code=1;
5790
5791          if (s->pict_type == B_TYPE) {
5792              s->b_code = get_bits(gb, 3);
5793          }else
5794              s->b_code=1;
5795
5796          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5797              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",
5798                  s->qscale, s->f_code, s->b_code,
5799                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5800                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5801                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5802                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5803          }
5804
5805          if(!s->scalability){
5806              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5807                  skip_bits1(gb); // vop shape coding type
5808              }
5809          }else{
5810              if(s->enhancement_type){
5811                  int load_backward_shape= get_bits1(gb);
5812                  if(load_backward_shape){
5813                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isnt supported\n");
5814                  }
5815              }
5816              skip_bits(gb, 2); //ref_select_code
5817          }
5818      }
5819      /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
5820      // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
5821      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5822          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5823          s->low_delay=1;
5824      }
5825
5826      s->picture_number++; // better than pic number==0 allways ;)
5827
5828      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5829      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5830
5831      if(s->workaround_bugs&FF_BUG_EDGE){
5832          s->h_edge_pos= s->width;
5833          s->v_edge_pos= s->height;
5834      }
5835      return 0;
5836 }
5837
5838 /**
5839  * decode mpeg4 headers
5840  * @return <0 if no VOP found (or a damaged one)
5841  *         FRAME_SKIPPED if a not coded VOP is found
5842  *         0 if a VOP is found
5843  */
5844 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
5845 {
5846     int startcode, v;
5847
5848     /* search next start code */
5849     align_get_bits(gb);
5850     startcode = 0xff;
5851     for(;;) {
5852         v = get_bits(gb, 8);
5853         startcode = ((startcode << 8) | v) & 0xffffffff;
5854
5855         if(get_bits_count(gb) >= gb->size_in_bits){
5856             if(gb->size_in_bits==8 && s->divx_version){
5857                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
5858                 return FRAME_SKIPED; //divx bug
5859             }else
5860                 return -1; //end of stream
5861         }
5862
5863         if((startcode&0xFFFFFF00) != 0x100)
5864             continue; //no startcode
5865
5866         if(s->avctx->debug&FF_DEBUG_STARTCODE){
5867             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
5868             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
5869             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
5870             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
5871             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
5872             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
5873             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
5874             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
5875             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
5876             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
5877             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
5878             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
5879             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
5880             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
5881             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
5882             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
5883             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
5884             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
5885             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
5886             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
5887             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start");
5888             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start");
5889             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start");
5890             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start");
5891             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start");
5892             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
5893             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
5894             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
5895             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
5896         }
5897
5898         if(startcode >= 0x120 && startcode <= 0x12F){
5899             if(decode_vol_header(s, gb) < 0)
5900                 return -1;
5901         }
5902         else if(startcode == USER_DATA_STARTCODE){
5903             decode_user_data(s, gb);
5904         }
5905         else if(startcode == GOP_STARTCODE){
5906             mpeg4_decode_gop_header(s, gb);
5907         }
5908         else if(startcode == VOP_STARTCODE){
5909             return decode_vop_header(s, gb);
5910         }
5911
5912         align_get_bits(gb);
5913         startcode = 0xff;
5914     }
5915 }
5916
5917 /* don't understand why they choose a different header ! */
5918 int intel_h263_decode_picture_header(MpegEncContext *s)
5919 {
5920     int format;
5921
5922     /* picture header */
5923     if (get_bits_long(&s->gb, 22) != 0x20) {
5924         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5925         return -1;
5926     }
5927     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5928
5929     if (get_bits1(&s->gb) != 1) {
5930         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5931         return -1;      /* marker */
5932     }
5933     if (get_bits1(&s->gb) != 0) {
5934         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5935         return -1;      /* h263 id */
5936     }
5937     skip_bits1(&s->gb); /* split screen off */
5938     skip_bits1(&s->gb); /* camera  off */
5939     skip_bits1(&s->gb); /* freeze picture release off */
5940
5941     format = get_bits(&s->gb, 3);
5942     if (format != 7) {
5943         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
5944         return -1;
5945     }
5946     s->h263_plus = 0;
5947
5948     s->pict_type = I_TYPE + get_bits1(&s->gb);
5949
5950     s->unrestricted_mv = get_bits1(&s->gb);
5951     s->h263_long_vectors = s->unrestricted_mv;
5952
5953     if (get_bits1(&s->gb) != 0) {
5954         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
5955         return -1;      /* SAC: off */
5956     }
5957     if (get_bits1(&s->gb) != 0) {
5958         s->obmc= 1;
5959         av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
5960 //        return -1;    /* advanced prediction mode: off */
5961     }
5962     if (get_bits1(&s->gb) != 0) {
5963         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
5964         return -1;      /* PB frame mode */
5965     }
5966
5967     /* skip unknown header garbage */
5968     skip_bits(&s->gb, 41);
5969
5970     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5971     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5972
5973     /* PEI */
5974     while (get_bits1(&s->gb) != 0) {
5975         skip_bits(&s->gb, 8);
5976     }
5977     s->f_code = 1;
5978
5979     s->y_dc_scale_table=
5980     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5981
5982     return 0;
5983 }
5984
5985 int flv_h263_decode_picture_header(MpegEncContext *s)
5986 {
5987     int format, width, height;
5988
5989     /* picture header */
5990     if (get_bits_long(&s->gb, 17) != 1) {
5991         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5992         return -1;
5993     }
5994     format = get_bits(&s->gb, 5);
5995     if (format != 0 && format != 1) {
5996         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
5997         return -1;
5998     }
5999     s->h263_flv = format+1;
6000     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6001     format = get_bits(&s->gb, 3);
6002     switch (format) {
6003     case 0:
6004         width = get_bits(&s->gb, 8);
6005         height = get_bits(&s->gb, 8);
6006         break;
6007     case 1:
6008         width = get_bits(&s->gb, 16);
6009         height = get_bits(&s->gb, 16);
6010         break;
6011     case 2:
6012         width = 352;
6013         height = 288;
6014         break;
6015     case 3:
6016         width = 176;
6017         height = 144;
6018         break;
6019     case 4:
6020         width = 128;
6021         height = 96;
6022         break;
6023     case 5:
6024         width = 320;
6025         height = 240;
6026         break;
6027     case 6:
6028         width = 160;
6029         height = 120;
6030         break;
6031     default:
6032         width = height = 0;
6033         break;
6034     }
6035     if ((width == 0) || (height == 0))
6036         return -1;
6037     s->width = width;
6038     s->height = height;
6039
6040     s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6041     if (s->pict_type > P_TYPE)
6042         s->pict_type = P_TYPE;
6043     skip_bits1(&s->gb); /* deblocking flag */
6044     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6045
6046     s->h263_plus = 0;
6047
6048     s->unrestricted_mv = 1;
6049     s->h263_long_vectors = 0;
6050
6051     /* PEI */
6052     while (get_bits1(&s->gb) != 0) {
6053         skip_bits(&s->gb, 8);
6054     }
6055     s->f_code = 1;
6056
6057     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6058         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6059                av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6060     }
6061
6062     s->y_dc_scale_table=
6063     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6064
6065     return 0;
6066 }