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