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

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