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