git.sesse.net Git - ffmpeg/blob - libavcodec/h263.c

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