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

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