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