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