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->avctx->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= ABS(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     const int bits_count= get_bits_count(&s->gb);
3192
3193     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3194         return 0;
3195     }
3196
3197     if(bits_count + 8 >= s->gb.size_in_bits){
3198         int v= show_bits(&s->gb, 8);
3199         v|= 0x7F >> (7-(bits_count&7));
3200
3201         if(v==0x7F)
3202             return 1;
3203     }else{
3204         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3205             int len;
3206             GetBitContext gb= s->gb;
3207
3208             skip_bits(&s->gb, 1);
3209             align_get_bits(&s->gb);
3210
3211             for(len=0; len<32; len++){
3212                 if(get_bits1(&s->gb)) break;
3213             }
3214
3215             s->gb= gb;
3216
3217             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3218                 return 1;
3219         }
3220     }
3221     return 0;
3222 }
3223
3224 /**
3225  * decodes the next video packet.
3226  * @return <0 if something went wrong
3227  */
3228 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3229 {
3230     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3231     int header_extension=0, mb_num, len;
3232
3233     /* is there enough space left for a video packet + header */
3234     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3235
3236     for(len=0; len<32; len++){
3237         if(get_bits1(&s->gb)) break;
3238     }
3239
3240     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3241         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3242         return -1;
3243     }
3244
3245     if(s->shape != RECT_SHAPE){
3246         header_extension= get_bits1(&s->gb);
3247         //FIXME more stuff here
3248     }
3249
3250     mb_num= get_bits(&s->gb, mb_num_bits);
3251     if(mb_num>=s->mb_num){
3252         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3253         return -1;
3254     }
3255     if(s->pict_type == B_TYPE){
3256         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3257         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3258     }
3259
3260     s->mb_x= mb_num % s->mb_width;
3261     s->mb_y= mb_num / s->mb_width;
3262
3263     if(s->shape != BIN_ONLY_SHAPE){
3264         int qscale= get_bits(&s->gb, s->quant_precision);
3265         if(qscale)
3266             s->chroma_qscale=s->qscale= qscale;
3267     }
3268
3269     if(s->shape == RECT_SHAPE){
3270         header_extension= get_bits1(&s->gb);
3271     }
3272     if(header_extension){
3273         int time_increment;
3274         int time_incr=0;
3275
3276         while (get_bits1(&s->gb) != 0)
3277             time_incr++;
3278
3279         check_marker(&s->gb, "before time_increment in video packed header");
3280         time_increment= get_bits(&s->gb, s->time_increment_bits);
3281         check_marker(&s->gb, "before vop_coding_type in video packed header");
3282
3283         skip_bits(&s->gb, 2); /* vop coding type */
3284         //FIXME not rect stuff here
3285
3286         if(s->shape != BIN_ONLY_SHAPE){
3287             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3288 //FIXME don't just ignore everything
3289             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3290                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3291                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3292             }
3293
3294             //FIXME reduced res stuff here
3295
3296             if (s->pict_type != I_TYPE) {
3297                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3298                 if(f_code==0){
3299                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3300                 }
3301             }
3302             if (s->pict_type == B_TYPE) {
3303                 int b_code = get_bits(&s->gb, 3);
3304                 if(b_code==0){
3305                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3306                 }
3307             }
3308         }
3309     }
3310     //FIXME new-pred stuff
3311
3312 //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));
3313
3314     return 0;
3315 }
3316
3317 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3318 {
3319     int c_wrap, c_xy, l_wrap, l_xy;
3320
3321     l_wrap= s->b8_stride;
3322     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3323     c_wrap= s->mb_stride;
3324     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3325
3326 #if 0
3327     /* clean DC */
3328     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3329     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3330     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3331 #endif
3332
3333     /* clean AC */
3334     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3335     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3336     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3337
3338     /* clean MV */
3339     // we can't clear the MVs as they might be needed by a b frame
3340 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3341 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3342     s->last_mv[0][0][0]=
3343     s->last_mv[0][0][1]=
3344     s->last_mv[1][0][0]=
3345     s->last_mv[1][0][1]= 0;
3346 }
3347
3348 /**
3349  * decodes the group of blocks / video packet header.
3350  * @return <0 if no resync found
3351  */
3352 int ff_h263_resync(MpegEncContext *s){
3353     int left, ret;
3354
3355     if(s->codec_id==CODEC_ID_MPEG4){
3356         skip_bits1(&s->gb);
3357         align_get_bits(&s->gb);
3358     }
3359
3360     if(show_bits(&s->gb, 16)==0){
3361         if(s->codec_id==CODEC_ID_MPEG4)
3362             ret= mpeg4_decode_video_packet_header(s);
3363         else
3364             ret= h263_decode_gob_header(s);
3365         if(ret>=0)
3366             return 0;
3367     }
3368     //ok, it's not where its supposed to be ...
3369     s->gb= s->last_resync_gb;
3370     align_get_bits(&s->gb);
3371     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3372
3373     for(;left>16+1+5+5; left-=8){
3374         if(show_bits(&s->gb, 16)==0){
3375             GetBitContext bak= s->gb;
3376
3377             if(s->codec_id==CODEC_ID_MPEG4)
3378                 ret= mpeg4_decode_video_packet_header(s);
3379             else
3380                 ret= h263_decode_gob_header(s);
3381             if(ret>=0)
3382                 return 0;
3383
3384             s->gb= bak;
3385         }
3386         skip_bits(&s->gb, 8);
3387     }
3388
3389     return -1;
3390 }
3391
3392 /**
3393  * gets the average motion vector for a GMC MB.
3394  * @param n either 0 for the x component or 1 for y
3395  * @returns the average MV for a GMC MB
3396  */
3397 static inline int get_amv(MpegEncContext *s, int n){
3398     int x, y, mb_v, sum, dx, dy, shift;
3399     int len = 1 << (s->f_code + 4);
3400     const int a= s->sprite_warping_accuracy;
3401
3402     if(s->workaround_bugs & FF_BUG_AMV)
3403         len >>= s->quarter_sample;
3404
3405     if(s->real_sprite_warping_points==1){
3406         if(s->divx_version==500 && s->divx_build==413)
3407             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3408         else
3409             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3410     }else{
3411         dx= s->sprite_delta[n][0];
3412         dy= s->sprite_delta[n][1];
3413         shift= s->sprite_shift[0];
3414         if(n) dy -= 1<<(shift + a + 1);
3415         else  dx -= 1<<(shift + a + 1);
3416         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3417
3418         sum=0;
3419         for(y=0; y<16; y++){
3420             int v;
3421
3422             v= mb_v + dy*y;
3423             //XXX FIXME optimize
3424             for(x=0; x<16; x++){
3425                 sum+= v>>shift;
3426                 v+= dx;
3427             }
3428         }
3429         sum= RSHIFT(sum, a+8-s->quarter_sample);
3430     }
3431
3432     if      (sum < -len) sum= -len;
3433     else if (sum >= len) sum= len-1;
3434
3435     return sum;
3436 }
3437
3438 /**
3439  * decodes first partition.
3440  * @return number of MBs decoded or <0 if an error occured
3441  */
3442 static int mpeg4_decode_partition_a(MpegEncContext *s){
3443     int mb_num;
3444     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3445
3446     /* decode first partition */
3447     mb_num=0;
3448     s->first_slice_line=1;
3449     for(; s->mb_y<s->mb_height; s->mb_y++){
3450         ff_init_block_index(s);
3451         for(; s->mb_x<s->mb_width; s->mb_x++){
3452             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3453             int cbpc;
3454             int dir=0;
3455
3456             mb_num++;
3457             ff_update_block_index(s);
3458             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3459                 s->first_slice_line=0;
3460
3461             if(s->pict_type==I_TYPE){
3462                 int i;
3463
3464                 do{
3465                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3466                         return mb_num-1;
3467                     }
3468
3469                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3470                     if (cbpc < 0){
3471                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3472                         return -1;
3473                     }
3474                 }while(cbpc == 8);
3475
3476                 s->cbp_table[xy]= cbpc & 3;
3477                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3478                 s->mb_intra = 1;
3479
3480                 if(cbpc & 4) {
3481                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3482                 }
3483                 s->current_picture.qscale_table[xy]= s->qscale;
3484
3485                 s->mbintra_table[xy]= 1;
3486                 for(i=0; i<6; i++){
3487                     int dc_pred_dir;
3488                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3489                     if(dc < 0){
3490                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3491                         return -1;
3492                     }
3493                     dir<<=1;
3494                     if(dc_pred_dir) dir|=1;
3495                 }
3496                 s->pred_dir_table[xy]= dir;
3497             }else{ /* P/S_TYPE */
3498                 int mx, my, pred_x, pred_y, bits;
3499                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3500                 const int stride= s->b8_stride*2;
3501
3502 try_again:
3503                 bits= show_bits(&s->gb, 17);
3504                 if(bits==MOTION_MARKER){
3505                     return mb_num-1;
3506                 }
3507                 skip_bits1(&s->gb);
3508                 if(bits&0x10000){
3509                     /* skip mb */
3510                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3511                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3512                         mx= get_amv(s, 0);
3513                         my= get_amv(s, 1);
3514                     }else{
3515                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3516                         mx=my=0;
3517                     }
3518                     mot_val[0       ]= mot_val[2       ]=
3519                     mot_val[0+stride]= mot_val[2+stride]= mx;
3520                     mot_val[1       ]= mot_val[3       ]=
3521                     mot_val[1+stride]= mot_val[3+stride]= my;
3522
3523                     if(s->mbintra_table[xy])
3524                         ff_clean_intra_table_entries(s);
3525                     continue;
3526                 }
3527
3528                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3529                 if (cbpc < 0){
3530                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3531                     return -1;
3532                 }
3533                 if(cbpc == 20)
3534                     goto try_again;
3535
3536                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3537
3538                 s->mb_intra = ((cbpc & 4) != 0);
3539
3540                 if(s->mb_intra){
3541                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3542                     s->mbintra_table[xy]= 1;
3543                     mot_val[0       ]= mot_val[2       ]=
3544                     mot_val[0+stride]= mot_val[2+stride]= 0;
3545                     mot_val[1       ]= mot_val[3       ]=
3546                     mot_val[1+stride]= mot_val[3+stride]= 0;
3547                 }else{
3548                     if(s->mbintra_table[xy])
3549                         ff_clean_intra_table_entries(s);
3550
3551                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3552                         s->mcsel= get_bits1(&s->gb);
3553                     else s->mcsel= 0;
3554
3555                     if ((cbpc & 16) == 0) {
3556                         /* 16x16 motion prediction */
3557
3558                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3559                         if(!s->mcsel){
3560                             mx = h263_decode_motion(s, pred_x, s->f_code);
3561                             if (mx >= 0xffff)
3562                                 return -1;
3563
3564                             my = h263_decode_motion(s, pred_y, s->f_code);
3565                             if (my >= 0xffff)
3566                                 return -1;
3567                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3568                         } else {
3569                             mx = get_amv(s, 0);
3570                             my = get_amv(s, 1);
3571                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3572                         }
3573
3574                         mot_val[0       ]= mot_val[2       ] =
3575                         mot_val[0+stride]= mot_val[2+stride]= mx;
3576                         mot_val[1       ]= mot_val[3       ]=
3577                         mot_val[1+stride]= mot_val[3+stride]= my;
3578                     } else {
3579                         int i;
3580                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3581                         for(i=0;i<4;i++) {
3582                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3583                             mx = h263_decode_motion(s, pred_x, s->f_code);
3584                             if (mx >= 0xffff)
3585                                 return -1;
3586
3587                             my = h263_decode_motion(s, pred_y, s->f_code);
3588                             if (my >= 0xffff)
3589                                 return -1;
3590                             mot_val[0] = mx;
3591                             mot_val[1] = my;
3592                         }
3593                     }
3594                 }
3595             }
3596         }
3597         s->mb_x= 0;
3598     }
3599
3600     return mb_num;
3601 }
3602
3603 /**
3604  * decode second partition.
3605  * @return <0 if an error occured
3606  */
3607 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3608     int mb_num=0;
3609     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3610
3611     s->mb_x= s->resync_mb_x;
3612     s->first_slice_line=1;
3613     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3614         ff_init_block_index(s);
3615         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3616             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3617
3618             mb_num++;
3619             ff_update_block_index(s);
3620             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3621                 s->first_slice_line=0;
3622
3623             if(s->pict_type==I_TYPE){
3624                 int ac_pred= get_bits1(&s->gb);
3625                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3626                 if(cbpy<0){
3627                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3628                     return -1;
3629                 }
3630
3631                 s->cbp_table[xy]|= cbpy<<2;
3632                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3633             }else{ /* P || S_TYPE */
3634                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3635                     int dir=0,i;
3636                     int ac_pred = get_bits1(&s->gb);
3637                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3638
3639                     if(cbpy<0){
3640                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3641                         return -1;
3642                     }
3643
3644                     if(s->cbp_table[xy] & 8) {
3645                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3646                     }
3647                     s->current_picture.qscale_table[xy]= s->qscale;
3648
3649                     for(i=0; i<6; i++){
3650                         int dc_pred_dir;
3651                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3652                         if(dc < 0){
3653                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3654                             return -1;
3655                         }
3656                         dir<<=1;
3657                         if(dc_pred_dir) dir|=1;
3658                     }
3659                     s->cbp_table[xy]&= 3; //remove dquant
3660                     s->cbp_table[xy]|= cbpy<<2;
3661                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3662                     s->pred_dir_table[xy]= dir;
3663                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3664                     s->current_picture.qscale_table[xy]= s->qscale;
3665                     s->cbp_table[xy]= 0;
3666                 }else{
3667                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3668
3669                     if(cbpy<0){
3670                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3671                         return -1;
3672                     }
3673
3674                     if(s->cbp_table[xy] & 8) {
3675                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3676                     }
3677                     s->current_picture.qscale_table[xy]= s->qscale;
3678
3679                     s->cbp_table[xy]&= 3; //remove dquant
3680                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3681                 }
3682             }
3683         }
3684         if(mb_num >= mb_count) return 0;
3685         s->mb_x= 0;
3686     }
3687     return 0;
3688 }
3689
3690 /**
3691  * decodes the first & second partition
3692  * @return <0 if error (and sets error type in the error_status_table)
3693  */
3694 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3695 {
3696     int mb_num;
3697     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3698     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3699
3700     mb_num= mpeg4_decode_partition_a(s);
3701     if(mb_num<0){
3702         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3703         return -1;
3704     }
3705
3706     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3707         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3708         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3709         return -1;
3710     }
3711
3712     s->mb_num_left= mb_num;
3713
3714     if(s->pict_type==I_TYPE){
3715         while(show_bits(&s->gb, 9) == 1)
3716             skip_bits(&s->gb, 9);
3717         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3718             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3719             return -1;
3720         }
3721     }else{
3722         while(show_bits(&s->gb, 10) == 1)
3723             skip_bits(&s->gb, 10);
3724         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3725             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3726             return -1;
3727         }
3728     }
3729     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3730
3731     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3732         if(s->pict_type==P_TYPE)
3733             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3734         return -1;
3735     }else{
3736         if(s->pict_type==P_TYPE)
3737             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3738     }
3739
3740     return 0;
3741 }
3742
3743 /**
3744  * decode partition C of one MB.
3745  * @return <0 if an error occured
3746  */
3747 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3748 {
3749     int cbp, mb_type;
3750     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3751
3752     mb_type= s->current_picture.mb_type[xy];
3753     cbp = s->cbp_table[xy];
3754
3755     s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3756
3757     if(s->current_picture.qscale_table[xy] != s->qscale){
3758         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3759     }
3760
3761     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3762         int i;
3763         for(i=0; i<4; i++){
3764             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3765             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3766         }
3767         s->mb_intra = IS_INTRA(mb_type);
3768
3769         if (IS_SKIP(mb_type)) {
3770             /* skip mb */
3771             for(i=0;i<6;i++)
3772                 s->block_last_index[i] = -1;
3773             s->mv_dir = MV_DIR_FORWARD;
3774             s->mv_type = MV_TYPE_16X16;
3775             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3776                 s->mcsel=1;
3777                 s->mb_skipped = 0;
3778             }else{
3779                 s->mcsel=0;
3780                 s->mb_skipped = 1;
3781             }
3782         }else if(s->mb_intra){
3783             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3784         }else if(!s->mb_intra){
3785 //            s->mcsel= 0; //FIXME do we need to init that
3786
3787             s->mv_dir = MV_DIR_FORWARD;
3788             if (IS_8X8(mb_type)) {
3789                 s->mv_type = MV_TYPE_8X8;
3790             } else {
3791                 s->mv_type = MV_TYPE_16X16;
3792             }
3793         }
3794     } else { /* I-Frame */
3795         s->mb_intra = 1;
3796         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3797     }
3798
3799     if (!IS_SKIP(mb_type)) {
3800         int i;
3801         s->dsp.clear_blocks(s->block[0]);
3802         /* decode each block */
3803         for (i = 0; i < 6; i++) {
3804             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3805                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3806                 return -1;
3807             }
3808             cbp+=cbp;
3809         }
3810     }
3811
3812     /* per-MB end of slice check */
3813
3814     if(--s->mb_num_left <= 0){
3815 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3816         if(mpeg4_is_resync(s))
3817             return SLICE_END;
3818         else
3819             return SLICE_NOEND;
3820     }else{
3821         if(mpeg4_is_resync(s)){
3822             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3823             if(s->cbp_table[xy+delta])
3824                 return SLICE_END;
3825         }
3826         return SLICE_OK;
3827     }
3828 }
3829
3830 /**
3831  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3832  */
3833 static void preview_obmc(MpegEncContext *s){
3834     GetBitContext gb= s->gb;
3835
3836     int cbpc, i, pred_x, pred_y, mx, my;
3837     int16_t *mot_val;
3838     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3839     const int stride= s->b8_stride*2;
3840
3841     for(i=0; i<4; i++)
3842         s->block_index[i]+= 2;
3843     for(i=4; i<6; i++)
3844         s->block_index[i]+= 1;
3845     s->mb_x++;
3846
3847     assert(s->pict_type == P_TYPE);
3848
3849     do{
3850         if (get_bits1(&s->gb)) {
3851             /* skip mb */
3852             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3853             mot_val[0       ]= mot_val[2       ]=
3854             mot_val[0+stride]= mot_val[2+stride]= 0;
3855             mot_val[1       ]= mot_val[3       ]=
3856             mot_val[1+stride]= mot_val[3+stride]= 0;
3857
3858             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3859             goto end;
3860         }
3861         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3862     }while(cbpc == 20);
3863
3864     if(cbpc & 4){
3865         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3866     }else{
3867         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3868         if (cbpc & 8) {
3869             if(s->modified_quant){
3870                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3871                 else                  skip_bits(&s->gb, 5);
3872             }else
3873                 skip_bits(&s->gb, 2);
3874         }
3875
3876         if ((cbpc & 16) == 0) {
3877                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3878                 /* 16x16 motion prediction */
3879                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3880                 if (s->umvplus)
3881                    mx = h263p_decode_umotion(s, pred_x);
3882                 else
3883                    mx = h263_decode_motion(s, pred_x, 1);
3884
3885                 if (s->umvplus)
3886                    my = h263p_decode_umotion(s, pred_y);
3887                 else
3888                    my = h263_decode_motion(s, pred_y, 1);
3889
3890                 mot_val[0       ]= mot_val[2       ]=
3891                 mot_val[0+stride]= mot_val[2+stride]= mx;
3892                 mot_val[1       ]= mot_val[3       ]=
3893                 mot_val[1+stride]= mot_val[3+stride]= my;
3894         } else {
3895             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3896             for(i=0;i<4;i++) {
3897                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3898                 if (s->umvplus)
3899                   mx = h263p_decode_umotion(s, pred_x);
3900                 else
3901                   mx = h263_decode_motion(s, pred_x, 1);
3902
3903                 if (s->umvplus)
3904                   my = h263p_decode_umotion(s, pred_y);
3905                 else
3906                   my = h263_decode_motion(s, pred_y, 1);
3907                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3908                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3909                 mot_val[0] = mx;
3910                 mot_val[1] = my;
3911             }
3912         }
3913     }
3914 end:
3915
3916     for(i=0; i<4; i++)
3917         s->block_index[i]-= 2;
3918     for(i=4; i<6; i++)
3919         s->block_index[i]-= 1;
3920     s->mb_x--;
3921
3922     s->gb= gb;
3923 }
3924
3925 static void h263_decode_dquant(MpegEncContext *s){
3926     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3927
3928     if(s->modified_quant){
3929         if(get_bits1(&s->gb))
3930             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3931         else
3932             s->qscale= get_bits(&s->gb, 5);
3933     }else
3934         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3935     ff_set_qscale(s, s->qscale);
3936 }
3937
3938 int ff_h263_decode_mb(MpegEncContext *s,
3939                       DCTELEM block[6][64])
3940 {
3941     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3942     int16_t *mot_val;
3943     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3944
3945     assert(!s->h263_pred);
3946
3947     if (s->pict_type == P_TYPE) {
3948         do{
3949             if (get_bits1(&s->gb)) {
3950                 /* skip mb */
3951                 s->mb_intra = 0;
3952                 for(i=0;i<6;i++)
3953                     s->block_last_index[i] = -1;
3954                 s->mv_dir = MV_DIR_FORWARD;
3955                 s->mv_type = MV_TYPE_16X16;
3956                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3957                 s->mv[0][0][0] = 0;
3958                 s->mv[0][0][1] = 0;
3959                 s->mb_skipped = !(s->obmc | s->loop_filter);
3960                 goto end;
3961             }
3962             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3963             //fprintf(stderr, "\tCBPC: %d", cbpc);
3964             if (cbpc < 0){
3965                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3966                 return -1;
3967             }
3968         }while(cbpc == 20);
3969
3970         s->dsp.clear_blocks(s->block[0]);
3971
3972         dquant = cbpc & 8;
3973         s->mb_intra = ((cbpc & 4) != 0);
3974         if (s->mb_intra) goto intra;
3975
3976         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3977
3978         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3979             cbpy ^= 0xF;
3980
3981         cbp = (cbpc & 3) | (cbpy << 2);
3982         if (dquant) {
3983             h263_decode_dquant(s);
3984         }
3985
3986         s->mv_dir = MV_DIR_FORWARD;
3987         if ((cbpc & 16) == 0) {
3988             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3989             /* 16x16 motion prediction */
3990             s->mv_type = MV_TYPE_16X16;
3991             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3992             if (s->umvplus)
3993                mx = h263p_decode_umotion(s, pred_x);
3994             else
3995                mx = h263_decode_motion(s, pred_x, 1);
3996
3997             if (mx >= 0xffff)
3998                 return -1;
3999
4000             if (s->umvplus)
4001                my = h263p_decode_umotion(s, pred_y);
4002             else
4003                my = h263_decode_motion(s, pred_y, 1);
4004
4005             if (my >= 0xffff)
4006                 return -1;
4007             s->mv[0][0][0] = mx;
4008             s->mv[0][0][1] = my;
4009
4010             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4011                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4012         } else {
4013             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4014             s->mv_type = MV_TYPE_8X8;
4015             for(i=0;i<4;i++) {
4016                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4017                 if (s->umvplus)
4018                   mx = h263p_decode_umotion(s, pred_x);
4019                 else
4020                   mx = h263_decode_motion(s, pred_x, 1);
4021                 if (mx >= 0xffff)
4022                     return -1;
4023
4024                 if (s->umvplus)
4025                   my = h263p_decode_umotion(s, pred_y);
4026                 else
4027                   my = h263_decode_motion(s, pred_y, 1);
4028                 if (my >= 0xffff)
4029                     return -1;
4030                 s->mv[0][i][0] = mx;
4031                 s->mv[0][i][1] = my;
4032                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4033                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4034                 mot_val[0] = mx;
4035                 mot_val[1] = my;
4036             }
4037         }
4038
4039         /* decode each block */
4040         for (i = 0; i < 6; i++) {
4041             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4042                 return -1;
4043             cbp+=cbp;
4044         }
4045
4046         if(s->obmc){
4047             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4048                 preview_obmc(s);
4049         }
4050     } else if(s->pict_type==B_TYPE) {
4051         int mb_type;
4052         const int stride= s->b8_stride;
4053         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4054         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4055 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4056
4057         //FIXME ugly
4058         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4059         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4060         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4061         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4062
4063         do{
4064             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4065             if (mb_type < 0){
4066                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4067                 return -1;
4068             }
4069
4070             mb_type= h263_mb_type_b_map[ mb_type ];
4071         }while(!mb_type);
4072
4073         s->mb_intra = IS_INTRA(mb_type);
4074         if(HAS_CBP(mb_type)){
4075             s->dsp.clear_blocks(s->block[0]);
4076             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4077             if(s->mb_intra){
4078                 dquant = IS_QUANT(mb_type);
4079                 goto intra;
4080             }
4081
4082             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4083
4084             if (cbpy < 0){
4085                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4086                 return -1;
4087             }
4088
4089             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4090                 cbpy ^= 0xF;
4091
4092             cbp = (cbpc & 3) | (cbpy << 2);
4093         }else
4094             cbp=0;
4095
4096         assert(!s->mb_intra);
4097
4098         if(IS_QUANT(mb_type)){
4099             h263_decode_dquant(s);
4100         }
4101
4102         if(IS_DIRECT(mb_type)){
4103             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4104             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4105         }else{
4106             s->mv_dir = 0;
4107             s->mv_type= MV_TYPE_16X16;
4108 //FIXME UMV
4109
4110             if(USES_LIST(mb_type, 0)){
4111                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4112                 s->mv_dir = MV_DIR_FORWARD;
4113
4114                 mx = h263_decode_motion(s, mx, 1);
4115                 my = h263_decode_motion(s, my, 1);
4116
4117                 s->mv[0][0][0] = mx;
4118                 s->mv[0][0][1] = my;
4119                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4120                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4121             }
4122
4123             if(USES_LIST(mb_type, 1)){
4124                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4125                 s->mv_dir |= MV_DIR_BACKWARD;
4126
4127                 mx = h263_decode_motion(s, mx, 1);
4128                 my = h263_decode_motion(s, my, 1);
4129
4130                 s->mv[1][0][0] = mx;
4131                 s->mv[1][0][1] = my;
4132                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4133                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4134             }
4135         }
4136
4137         s->current_picture.mb_type[xy]= mb_type;
4138
4139         /* decode each block */
4140         for (i = 0; i < 6; i++) {
4141             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4142                 return -1;
4143             cbp+=cbp;
4144         }
4145     } else { /* I-Frame */
4146         do{
4147             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4148             if (cbpc < 0){
4149                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4150                 return -1;
4151             }
4152         }while(cbpc == 8);
4153
4154         s->dsp.clear_blocks(s->block[0]);
4155
4156         dquant = cbpc & 4;
4157         s->mb_intra = 1;
4158 intra:
4159         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4160         if (s->h263_aic) {
4161             s->ac_pred = get_bits1(&s->gb);
4162             if(s->ac_pred){
4163                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4164
4165                 s->h263_aic_dir = get_bits1(&s->gb);
4166             }
4167         }else
4168             s->ac_pred = 0;
4169
4170         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4171         if(cbpy<0){
4172             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4173             return -1;
4174         }
4175         cbp = (cbpc & 3) | (cbpy << 2);
4176         if (dquant) {
4177             h263_decode_dquant(s);
4178         }
4179
4180         /* decode each block */
4181         for (i = 0; i < 6; i++) {
4182             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4183                 return -1;
4184             cbp+=cbp;
4185         }
4186     }
4187 end:
4188
4189         /* per-MB end of slice check */
4190     {
4191         int v= show_bits(&s->gb, 16);
4192
4193         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4194             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4195         }
4196
4197         if(v==0)
4198             return SLICE_END;
4199     }
4200
4201     return SLICE_OK;
4202 }
4203
4204 int ff_mpeg4_decode_mb(MpegEncContext *s,
4205                       DCTELEM block[6][64])
4206 {
4207     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4208     int16_t *mot_val;
4209     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4210     const int xy= s->mb_x + s->mb_y * s->mb_stride;
4211
4212     assert(s->h263_pred);
4213
4214     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4215         do{
4216             if (get_bits1(&s->gb)) {
4217                 /* skip mb */
4218                 s->mb_intra = 0;
4219                 for(i=0;i<6;i++)
4220                     s->block_last_index[i] = -1;
4221                 s->mv_dir = MV_DIR_FORWARD;
4222                 s->mv_type = MV_TYPE_16X16;
4223                 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4224                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4225                     s->mcsel=1;
4226                     s->mv[0][0][0]= get_amv(s, 0);
4227                     s->mv[0][0][1]= get_amv(s, 1);
4228
4229                     s->mb_skipped = 0;
4230                 }else{
4231                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4232                     s->mcsel=0;
4233                     s->mv[0][0][0] = 0;
4234                     s->mv[0][0][1] = 0;
4235                     s->mb_skipped = 1;
4236                 }
4237                 goto end;
4238             }
4239             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4240             //fprintf(stderr, "\tCBPC: %d", cbpc);
4241             if (cbpc < 0){
4242                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4243                 return -1;
4244             }
4245         }while(cbpc == 20);
4246
4247         s->dsp.clear_blocks(s->block[0]);
4248         dquant = cbpc & 8;
4249         s->mb_intra = ((cbpc & 4) != 0);
4250         if (s->mb_intra) goto intra;
4251
4252         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4253             s->mcsel= get_bits1(&s->gb);
4254         else s->mcsel= 0;
4255         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4256
4257         cbp = (cbpc & 3) | (cbpy << 2);
4258         if (dquant) {
4259             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4260         }
4261         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4262             s->interlaced_dct= get_bits1(&s->gb);
4263
4264         s->mv_dir = MV_DIR_FORWARD;
4265         if ((cbpc & 16) == 0) {
4266             if(s->mcsel){
4267                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4268                 /* 16x16 global motion prediction */
4269                 s->mv_type = MV_TYPE_16X16;
4270                 mx= get_amv(s, 0);
4271                 my= get_amv(s, 1);
4272                 s->mv[0][0][0] = mx;
4273                 s->mv[0][0][1] = my;
4274             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4275                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4276                 /* 16x8 field motion prediction */
4277                 s->mv_type= MV_TYPE_FIELD;
4278
4279                 s->field_select[0][0]= get_bits1(&s->gb);
4280                 s->field_select[0][1]= get_bits1(&s->gb);
4281
4282                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4283
4284                 for(i=0; i<2; i++){
4285                     mx = h263_decode_motion(s, pred_x, s->f_code);
4286                     if (mx >= 0xffff)
4287                         return -1;
4288
4289                     my = h263_decode_motion(s, pred_y/2, s->f_code);
4290                     if (my >= 0xffff)
4291                         return -1;
4292
4293                     s->mv[0][i][0] = mx;
4294                     s->mv[0][i][1] = my;
4295                 }
4296             }else{
4297                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4298                 /* 16x16 motion prediction */
4299                 s->mv_type = MV_TYPE_16X16;
4300                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4301                 mx = h263_decode_motion(s, pred_x, s->f_code);
4302
4303                 if (mx >= 0xffff)
4304                     return -1;
4305
4306                 my = h263_decode_motion(s, pred_y, s->f_code);
4307
4308                 if (my >= 0xffff)
4309                     return -1;
4310                 s->mv[0][0][0] = mx;
4311                 s->mv[0][0][1] = my;
4312             }
4313         } else {
4314             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4315             s->mv_type = MV_TYPE_8X8;
4316             for(i=0;i<4;i++) {
4317                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4318                 mx = h263_decode_motion(s, pred_x, s->f_code);
4319                 if (mx >= 0xffff)
4320                     return -1;
4321
4322                 my = h263_decode_motion(s, pred_y, s->f_code);
4323                 if (my >= 0xffff)
4324                     return -1;
4325                 s->mv[0][i][0] = mx;
4326                 s->mv[0][i][1] = my;
4327                 mot_val[0] = mx;
4328                 mot_val[1] = my;
4329             }
4330         }
4331     } else if(s->pict_type==B_TYPE) {
4332         int modb1; // first bit of modb
4333         int modb2; // second bit of modb
4334         int mb_type;
4335
4336         s->mb_intra = 0; //B-frames never contain intra blocks
4337         s->mcsel=0;      //     ...               true gmc blocks
4338
4339         if(s->mb_x==0){
4340             for(i=0; i<2; i++){
4341                 s->last_mv[i][0][0]=
4342                 s->last_mv[i][0][1]=
4343                 s->last_mv[i][1][0]=
4344                 s->last_mv[i][1][1]= 0;
4345             }
4346         }
4347
4348         /* if we skipped it in the future P Frame than skip it now too */
4349         s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4350
4351         if(s->mb_skipped){
4352                 /* skip mb */
4353             for(i=0;i<6;i++)
4354                 s->block_last_index[i] = -1;
4355
4356             s->mv_dir = MV_DIR_FORWARD;
4357             s->mv_type = MV_TYPE_16X16;
4358             s->mv[0][0][0] = 0;
4359             s->mv[0][0][1] = 0;
4360             s->mv[1][0][0] = 0;
4361             s->mv[1][0][1] = 0;
4362             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4363             goto end;
4364         }
4365
4366         modb1= get_bits1(&s->gb);
4367         if(modb1){
4368             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4369             cbp=0;
4370         }else{
4371             modb2= get_bits1(&s->gb);
4372             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4373             if(mb_type<0){
4374                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4375                 return -1;
4376             }
4377             mb_type= mb_type_b_map[ mb_type ];
4378             if(modb2) cbp= 0;
4379             else{
4380                 s->dsp.clear_blocks(s->block[0]);
4381                 cbp= get_bits(&s->gb, 6);
4382             }
4383
4384             if ((!IS_DIRECT(mb_type)) && cbp) {
4385                 if(get_bits1(&s->gb)){
4386                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4387                 }
4388             }
4389
4390             if(!s->progressive_sequence){
4391                 if(cbp)
4392                     s->interlaced_dct= get_bits1(&s->gb);
4393
4394                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4395                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4396                     mb_type &= ~MB_TYPE_16x16;
4397
4398                     if(USES_LIST(mb_type, 0)){
4399                         s->field_select[0][0]= get_bits1(&s->gb);
4400                         s->field_select[0][1]= get_bits1(&s->gb);
4401                     }
4402                     if(USES_LIST(mb_type, 1)){
4403                         s->field_select[1][0]= get_bits1(&s->gb);
4404                         s->field_select[1][1]= get_bits1(&s->gb);
4405                     }
4406                 }
4407             }
4408
4409             s->mv_dir = 0;
4410             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4411                 s->mv_type= MV_TYPE_16X16;
4412
4413                 if(USES_LIST(mb_type, 0)){
4414                     s->mv_dir = MV_DIR_FORWARD;
4415
4416                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4417                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4418                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4419                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4420                 }
4421
4422                 if(USES_LIST(mb_type, 1)){
4423                     s->mv_dir |= MV_DIR_BACKWARD;
4424
4425                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4426                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4427                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4428                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4429                 }
4430             }else if(!IS_DIRECT(mb_type)){
4431                 s->mv_type= MV_TYPE_FIELD;
4432
4433                 if(USES_LIST(mb_type, 0)){
4434                     s->mv_dir = MV_DIR_FORWARD;
4435
4436                     for(i=0; i<2; i++){
4437                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4438                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4439                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4440                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4441                     }
4442                 }
4443
4444                 if(USES_LIST(mb_type, 1)){
4445                     s->mv_dir |= MV_DIR_BACKWARD;
4446
4447                     for(i=0; i<2; i++){
4448                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4449                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4450                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4451                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4452                     }
4453                 }
4454             }
4455         }
4456
4457         if(IS_DIRECT(mb_type)){
4458             if(IS_SKIP(mb_type))
4459                 mx=my=0;
4460             else{
4461                 mx = h263_decode_motion(s, 0, 1);
4462                 my = h263_decode_motion(s, 0, 1);
4463             }
4464
4465             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4466             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4467         }
4468         s->current_picture.mb_type[xy]= mb_type;
4469     } else { /* I-Frame */
4470         do{
4471             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4472             if (cbpc < 0){
4473                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4474                 return -1;
4475             }
4476         }while(cbpc == 8);
4477
4478         dquant = cbpc & 4;
4479         s->mb_intra = 1;
4480 intra:
4481         s->ac_pred = get_bits1(&s->gb);
4482         if(s->ac_pred)
4483             s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4484         else
4485             s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4486
4487         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4488         if(cbpy<0){
4489             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4490             return -1;
4491         }
4492         cbp = (cbpc & 3) | (cbpy << 2);
4493
4494         s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4495
4496         if (dquant) {
4497             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4498         }
4499
4500         if(!s->progressive_sequence)
4501             s->interlaced_dct= get_bits1(&s->gb);
4502
4503         s->dsp.clear_blocks(s->block[0]);
4504         /* decode each block */
4505         for (i = 0; i < 6; i++) {
4506             if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4507                 return -1;
4508             cbp+=cbp;
4509         }
4510         goto end;
4511     }
4512
4513     /* decode each block */
4514     for (i = 0; i < 6; i++) {
4515         if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4516             return -1;
4517         cbp+=cbp;
4518     }
4519 end:
4520
4521         /* per-MB end of slice check */
4522     if(s->codec_id==CODEC_ID_MPEG4){
4523 #if 0 //http://standards.iso.org/ittf/PubliclyAvailableStandards/ISO_IEC_14496-4_2004_Conformance_Testing/video_conformance/version_1/simple/ERROR.ZIP/mit025.m4v needs this but its unclear if the mpeg4 standard allows this at all (MN)
4524         if(s->pict_type != B_TYPE){
4525             while(show_bits(&s->gb, 9 + (s->pict_type == P_TYPE)) == 1)
4526                 skip_bits(&s->gb, 9 + (s->pict_type == P_TYPE));
4527         }
4528 #endif
4529         if(mpeg4_is_resync(s)){
4530             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4531             if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4532                 return SLICE_OK;
4533             return SLICE_END;
4534         }
4535     }
4536
4537     return SLICE_OK;
4538 }
4539
4540 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4541 {
4542     int code, val, sign, shift, l;
4543     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4544
4545     if (code == 0)
4546         return pred;
4547     if (code < 0)
4548         return 0xffff;
4549
4550     sign = get_bits1(&s->gb);
4551     shift = f_code - 1;
4552     val = code;
4553     if (shift) {
4554         val = (val - 1) << shift;
4555         val |= get_bits(&s->gb, shift);
4556         val++;
4557     }
4558     if (sign)
4559         val = -val;
4560     val += pred;
4561
4562     /* modulo decoding */
4563     if (!s->h263_long_vectors) {
4564         l = INT_BIT - 5 - f_code;
4565         val = (val<<l)>>l;
4566     } else {
4567         /* horrible h263 long vector mode */
4568         if (pred < -31 && val < -63)
4569             val += 64;
4570         if (pred > 32 && val > 63)
4571             val -= 64;
4572
4573     }
4574     return val;
4575 }
4576
4577 /* Decodes RVLC of H.263+ UMV */
4578 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4579 {
4580    int code = 0, sign;
4581
4582    if (get_bits1(&s->gb)) /* Motion difference = 0 */
4583       return pred;
4584
4585    code = 2 + get_bits1(&s->gb);
4586
4587    while (get_bits1(&s->gb))
4588    {
4589       code <<= 1;
4590       code += get_bits1(&s->gb);
4591    }
4592    sign = code & 1;
4593    code >>= 1;
4594
4595    code = (sign) ? (pred - code) : (pred + code);
4596 #ifdef DEBUG
4597    av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4598 #endif
4599    return code;
4600
4601 }
4602
4603 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4604                              int n, int coded)
4605 {
4606     int code, level, i, j, last, run;
4607     RLTable *rl = &rl_inter;
4608     const uint8_t *scan_table;
4609     GetBitContext gb= s->gb;
4610
4611     scan_table = s->intra_scantable.permutated;
4612     if (s->h263_aic && s->mb_intra) {
4613         rl = &rl_intra_aic;
4614         i = 0;
4615         if (s->ac_pred) {
4616             if (s->h263_aic_dir)
4617                 scan_table = s->intra_v_scantable.permutated; /* left */
4618             else
4619                 scan_table = s->intra_h_scantable.permutated; /* top */
4620         }
4621     } else if (s->mb_intra) {
4622         /* DC coef */
4623         if(s->codec_id == CODEC_ID_RV10){
4624 #ifdef CONFIG_RV10_DECODER
4625           if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4626             int component, diff;
4627             component = (n <= 3 ? 0 : n - 4 + 1);
4628             level = s->last_dc[component];
4629             if (s->rv10_first_dc_coded[component]) {
4630                 diff = rv_decode_dc(s, n);
4631                 if (diff == 0xffff)
4632                     return -1;
4633                 level += diff;
4634                 level = level & 0xff; /* handle wrap round */
4635                 s->last_dc[component] = level;
4636             } else {
4637                 s->rv10_first_dc_coded[component] = 1;
4638             }
4639           } else {
4640                 level = get_bits(&s->gb, 8);
4641                 if (level == 255)
4642                     level = 128;
4643           }
4644 #endif
4645         }else{
4646             level = get_bits(&s->gb, 8);
4647             if((level&0x7F) == 0){
4648                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4649                 if(s->error_resilience >= FF_ER_COMPLIANT)
4650                     return -1;
4651             }
4652             if (level == 255)
4653                 level = 128;
4654         }
4655         block[0] = level;
4656         i = 1;
4657     } else {
4658         i = 0;
4659     }
4660     if (!coded) {
4661         if (s->mb_intra && s->h263_aic)
4662             goto not_coded;
4663         s->block_last_index[n] = i - 1;
4664         return 0;
4665     }
4666 retry:
4667     for(;;) {
4668         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4669         if (code < 0){
4670             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4671             return -1;
4672         }
4673         if (code == rl->n) {
4674             /* escape */
4675             if (s->h263_flv > 1) {
4676                 int is11 = get_bits1(&s->gb);
4677                 last = get_bits1(&s->gb);
4678                 run = get_bits(&s->gb, 6);
4679                 if(is11){
4680                     level = get_sbits(&s->gb, 11);
4681                 } else {
4682                     level = get_sbits(&s->gb, 7);
4683                 }
4684             } else {
4685                 last = get_bits1(&s->gb);
4686                 run = get_bits(&s->gb, 6);
4687                 level = (int8_t)get_bits(&s->gb, 8);
4688                 if(level == -128){
4689                     if (s->codec_id == CODEC_ID_RV10) {
4690                         /* XXX: should patch encoder too */
4691                         level = get_sbits(&s->gb, 12);
4692                     }else{
4693                         level = get_bits(&s->gb, 5);
4694                         level |= get_sbits(&s->gb, 6)<<5;
4695                     }
4696                 }
4697             }
4698         } else {
4699             run = rl->table_run[code];
4700             level = rl->table_level[code];
4701             last = code >= rl->last;
4702             if (get_bits1(&s->gb))
4703                 level = -level;
4704         }
4705         i += run;
4706         if (i >= 64){
4707             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4708                 //looks like a hack but no, it's the way its supposed to work ...
4709                 rl = &rl_intra_aic;
4710                 i = 0;
4711                 s->gb= gb;
4712                 memset(block, 0, sizeof(DCTELEM)*64);
4713                 goto retry;
4714             }
4715             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4716             return -1;
4717         }
4718         j = scan_table[i];
4719         block[j] = level;
4720         if (last)
4721             break;
4722         i++;
4723     }
4724 not_coded:
4725     if (s->mb_intra && s->h263_aic) {
4726         h263_pred_acdc(s, block, n);
4727         i = 63;
4728     }
4729     s->block_last_index[n] = i;
4730     return 0;
4731 }
4732
4733 /**
4734  * decodes the dc value.
4735  * @param n block index (0-3 are luma, 4-5 are chroma)
4736  * @param dir_ptr the prediction direction will be stored here
4737  * @return the quantized dc
4738  */
4739 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4740 {
4741     int level, code;
4742
4743     if (n < 4)
4744         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4745     else
4746         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4747     if (code < 0 || code > 9 /* && s->nbit<9 */){
4748         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4749         return -1;
4750     }
4751     if (code == 0) {
4752         level = 0;
4753     } else {
4754         if(IS_3IV1){
4755             if(code==1)
4756                 level= 2*get_bits1(&s->gb)-1;
4757             else{
4758                 if(get_bits1(&s->gb))
4759                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
4760                 else
4761                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4762             }
4763         }else{
4764             level = get_xbits(&s->gb, code);
4765         }
4766
4767         if (code > 8){
4768             if(get_bits1(&s->gb)==0){ /* marker */
4769                 if(s->error_resilience>=2){
4770                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4771                     return -1;
4772                 }
4773             }
4774         }
4775     }
4776
4777     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4778 }
4779
4780 /**
4781  * decodes a block.
4782  * @return <0 if an error occured
4783  */
4784 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4785                               int n, int coded, int intra, int rvlc)
4786 {
4787     int level, i, last, run;
4788     int dc_pred_dir;
4789     RLTable * rl;
4790     RL_VLC_ELEM * rl_vlc;
4791     const uint8_t * scan_table;
4792     int qmul, qadd;
4793
4794     //Note intra & rvlc should be optimized away if this is inlined
4795
4796     if(intra) {
4797       if(s->use_intra_dc_vlc){
4798         /* DC coef */
4799         if(s->partitioned_frame){
4800             level = s->dc_val[0][ s->block_index[n] ];
4801             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4802             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4803             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4804         }else{
4805             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4806             if (level < 0)
4807                 return -1;
4808         }
4809         block[0] = level;
4810         i = 0;
4811       }else{
4812             i = -1;
4813             ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4814       }
4815         if (!coded)
4816             goto not_coded;
4817
4818         if(rvlc){
4819             rl = &rvlc_rl_intra;
4820             rl_vlc = rvlc_rl_intra.rl_vlc[0];
4821         }else{
4822             rl = &rl_intra;
4823             rl_vlc = rl_intra.rl_vlc[0];
4824         }
4825         if (s->ac_pred) {
4826             if (dc_pred_dir == 0)
4827                 scan_table = s->intra_v_scantable.permutated; /* left */
4828             else
4829                 scan_table = s->intra_h_scantable.permutated; /* top */
4830         } else {
4831             scan_table = s->intra_scantable.permutated;
4832         }
4833         qmul=1;
4834         qadd=0;
4835     } else {
4836         i = -1;
4837         if (!coded) {
4838             s->block_last_index[n] = i;
4839             return 0;
4840         }
4841         if(rvlc) rl = &rvlc_rl_inter;
4842         else     rl = &rl_inter;
4843
4844         scan_table = s->intra_scantable.permutated;
4845
4846         if(s->mpeg_quant){
4847             qmul=1;
4848             qadd=0;
4849             if(rvlc){
4850                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4851             }else{
4852                 rl_vlc = rl_inter.rl_vlc[0];
4853             }
4854         }else{
4855             qmul = s->qscale << 1;
4856             qadd = (s->qscale - 1) | 1;
4857             if(rvlc){
4858                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4859             }else{
4860                 rl_vlc = rl_inter.rl_vlc[s->qscale];
4861             }
4862         }
4863     }
4864   {
4865     OPEN_READER(re, &s->gb);
4866     for(;;) {
4867         UPDATE_CACHE(re, &s->gb);
4868         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4869         if (level==0) {
4870           /* escape */
4871           if(rvlc){
4872                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4873                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4874                     return -1;
4875                 }; SKIP_CACHE(re, &s->gb, 1);
4876
4877                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4878                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4879                 SKIP_COUNTER(re, &s->gb, 1+1+6);
4880                 UPDATE_CACHE(re, &s->gb);
4881
4882                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4883                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4884                     return -1;
4885                 }; SKIP_CACHE(re, &s->gb, 1);
4886
4887                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4888
4889                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4890                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4891                     return -1;
4892                 }; SKIP_CACHE(re, &s->gb, 5);
4893
4894                 level=  level * qmul + qadd;
4895                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4896                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4897
4898                 i+= run + 1;
4899                 if(last) i+=192;
4900           }else{
4901             int cache;
4902             cache= GET_CACHE(re, &s->gb);
4903
4904             if(IS_3IV1)
4905                 cache ^= 0xC0000000;
4906
4907             if (cache&0x80000000) {
4908                 if (cache&0x40000000) {
4909                     /* third escape */
4910                     SKIP_CACHE(re, &s->gb, 2);
4911                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4912                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4913                     SKIP_COUNTER(re, &s->gb, 2+1+6);
4914                     UPDATE_CACHE(re, &s->gb);
4915
4916                     if(IS_3IV1){
4917                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4918                     }else{
4919                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4920                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4921                             return -1;
4922                         }; SKIP_CACHE(re, &s->gb, 1);
4923
4924                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4925
4926                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4927                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4928                             return -1;
4929                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
4930
4931                         SKIP_COUNTER(re, &s->gb, 1+12+1);
4932                     }
4933
4934 #if 0
4935                     if(s->error_resilience >= FF_ER_COMPLIANT){
4936                         const int abs_level= ABS(level);
4937                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4938                             const int run1= run - rl->max_run[last][abs_level] - 1;
4939                             if(abs_level <= rl->max_level[last][run]){
4940                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4941                                 return -1;
4942                             }
4943                             if(s->error_resilience > FF_ER_COMPLIANT){
4944                                 if(abs_level <= rl->max_level[last][run]*2){
4945                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4946                                     return -1;
4947                                 }
4948                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4949                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4950                                     return -1;
4951                                 }
4952                             }
4953                         }
4954                     }
4955 #endif
4956                     if (level>0) level= level * qmul + qadd;
4957                     else         level= level * qmul - qadd;
4958
4959                     if((unsigned)(level + 2048) > 4095){
4960                         if(s->error_resilience > FF_ER_COMPLIANT){
4961                             if(level > 2560 || level<-2560){
4962                                 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4963                                 return -1;
4964                             }
4965                         }
4966                         level= level<0 ? -2048 : 2047;
4967                     }
4968
4969                     i+= run + 1;
4970                     if(last) i+=192;
4971                 } else {
4972                     /* second escape */
4973 #if MIN_CACHE_BITS < 20
4974                     LAST_SKIP_BITS(re, &s->gb, 2);
4975                     UPDATE_CACHE(re, &s->gb);
4976 #else
4977                     SKIP_BITS(re, &s->gb, 2);
4978 #endif
4979                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4980                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4981                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4982                     LAST_SKIP_BITS(re, &s->gb, 1);
4983                 }
4984             } else {
4985                 /* first escape */
4986 #if MIN_CACHE_BITS < 19
4987                 LAST_SKIP_BITS(re, &s->gb, 1);
4988                 UPDATE_CACHE(re, &s->gb);
4989 #else
4990                 SKIP_BITS(re, &s->gb, 1);
4991 #endif
4992                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4993                 i+= run;
4994                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4995                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4996                 LAST_SKIP_BITS(re, &s->gb, 1);
4997             }
4998           }
4999         } else {
5000             i+= run;
5001             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5002             LAST_SKIP_BITS(re, &s->gb, 1);
5003         }
5004         if (i > 62){
5005             i-= 192;
5006             if(i&(~63)){
5007                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5008                 return -1;
5009             }
5010
5011             block[scan_table[i]] = level;
5012             break;
5013         }
5014
5015         block[scan_table[i]] = level;
5016     }
5017     CLOSE_READER(re, &s->gb);
5018   }
5019  not_coded:
5020     if (intra) {
5021         if(!s->use_intra_dc_vlc){
5022             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5023
5024             i -= i>>31; //if(i == -1) i=0;
5025         }
5026
5027         mpeg4_pred_ac(s, block, n, dc_pred_dir);
5028         if (s->ac_pred) {
5029             i = 63; /* XXX: not optimal */
5030         }
5031     }
5032     s->block_last_index[n] = i;
5033     return 0;
5034 }
5035
5036 /* most is hardcoded. should extend to handle all h263 streams */
5037 int h263_decode_picture_header(MpegEncContext *s)
5038 {
5039     int format, width, height, i;
5040     uint32_t startcode;
5041
5042     align_get_bits(&s->gb);
5043
5044     startcode= get_bits(&s->gb, 22-8);
5045
5046     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5047         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5048
5049         if(startcode == 0x20)
5050             break;
5051     }
5052
5053     if (startcode != 0x20) {
5054         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5055         return -1;
5056     }
5057     /* temporal reference */
5058     i = get_bits(&s->gb, 8); /* picture timestamp */
5059     if( (s->picture_number&~0xFF)+i < s->picture_number)
5060         i+= 256;
5061     s->current_picture_ptr->pts=
5062     s->picture_number= (s->picture_number&~0xFF) + i;
5063
5064     /* PTYPE starts here */
5065     if (get_bits1(&s->gb) != 1) {
5066         /* marker */
5067         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5068         return -1;
5069     }
5070     if (get_bits1(&s->gb) != 0) {
5071         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5072         return -1;      /* h263 id */
5073     }
5074     skip_bits1(&s->gb);         /* split screen off */
5075     skip_bits1(&s->gb);         /* camera  off */
5076     skip_bits1(&s->gb);         /* freeze picture release off */
5077
5078     format = get_bits(&s->gb, 3);
5079     /*
5080         0    forbidden
5081         1    sub-QCIF
5082         10   QCIF
5083         7       extended PTYPE (PLUSPTYPE)
5084     */
5085
5086     if (format != 7 && format != 6) {
5087         s->h263_plus = 0;
5088         /* H.263v1 */
5089         width = h263_format[format][0];
5090         height = h263_format[format][1];
5091         if (!width)
5092             return -1;
5093
5094         s->pict_type = I_TYPE + get_bits1(&s->gb);
5095
5096         s->h263_long_vectors = get_bits1(&s->gb);
5097
5098         if (get_bits1(&s->gb) != 0) {
5099             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5100             return -1; /* SAC: off */
5101         }
5102         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5103         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5104
5105         if (get_bits1(&s->gb) != 0) {
5106             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5107             return -1; /* not PB frame */
5108         }
5109         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5110         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5111
5112         s->width = width;
5113         s->height = height;
5114         s->avctx->sample_aspect_ratio= (AVRational){12,11};
5115         s->avctx->time_base= (AVRational){1001, 30000};
5116     } else {
5117         int ufep;
5118
5119         /* H.263v2 */
5120         s->h263_plus = 1;
5121         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5122
5123         /* ufep other than 0 and 1 are reserved */
5124         if (ufep == 1) {
5125             /* OPPTYPE */
5126             format = get_bits(&s->gb, 3);
5127             dprintf("ufep=1, format: %d\n", format);
5128             s->custom_pcf= get_bits1(&s->gb);
5129             s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5130             if (get_bits1(&s->gb) != 0) {
5131                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5132             }
5133             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5134             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5135             s->loop_filter= get_bits1(&s->gb);
5136             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5137
5138             s->h263_slice_structured= get_bits1(&s->gb);
5139             if (get_bits1(&s->gb) != 0) {
5140                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5141             }
5142             if (get_bits1(&s->gb) != 0) {
5143                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5144             }
5145             s->alt_inter_vlc= get_bits1(&s->gb);
5146             s->modified_quant= get_bits1(&s->gb);
5147             if(s->modified_quant)
5148                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5149
5150             skip_bits(&s->gb, 1); /* Prevent start code emulation */
5151
5152             skip_bits(&s->gb, 3); /* Reserved */
5153         } else if (ufep != 0) {
5154             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5155             return -1;
5156         }
5157
5158         /* MPPTYPE */
5159         s->pict_type = get_bits(&s->gb, 3);
5160         switch(s->pict_type){
5161         case 0: s->pict_type= I_TYPE;break;
5162         case 1: s->pict_type= P_TYPE;break;
5163         case 3: s->pict_type= B_TYPE;break;
5164         case 7: s->pict_type= I_TYPE;break; //ZYGO
5165         default:
5166             return -1;
5167         }
5168         skip_bits(&s->gb, 2);
5169         s->no_rounding = get_bits1(&s->gb);
5170         skip_bits(&s->gb, 4);
5171
5172         /* Get the picture dimensions */
5173         if (ufep) {
5174             if (format == 6) {
5175                 /* Custom Picture Format (CPFMT) */
5176                 s->aspect_ratio_info = get_bits(&s->gb, 4);
5177                 dprintf("aspect: %d\n", s->aspect_ratio_info);
5178                 /* aspect ratios:
5179                 0 - forbidden
5180                 1 - 1:1
5181                 2 - 12:11 (CIF 4:3)
5182                 3 - 10:11 (525-type 4:3)
5183                 4 - 16:11 (CIF 16:9)
5184                 5 - 40:33 (525-type 16:9)
5185                 6-14 - reserved
5186                 */
5187                 width = (get_bits(&s->gb, 9) + 1) * 4;
5188                 skip_bits1(&s->gb);
5189                 height = get_bits(&s->gb, 9) * 4;
5190                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5191                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5192                     /* aspected dimensions */
5193                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5194                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5195                 }else{
5196                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5197                 }
5198             } else {
5199                 width = h263_format[format][0];
5200                 height = h263_format[format][1];
5201                 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5202             }
5203             if ((width == 0) || (height == 0))
5204                 return -1;
5205             s->width = width;
5206             s->height = height;
5207
5208             if(s->custom_pcf){
5209                 int gcd;
5210                 s->avctx->time_base.den= 1800000;
5211                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5212                 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5213                 if(s->avctx->time_base.num == 0){
5214                     av_log(s, AV_LOG_ERROR, "zero framerate\n");
5215                     return -1;
5216                 }
5217                 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5218                 s->avctx->time_base.den /= gcd;
5219                 s->avctx->time_base.num /= gcd;
5220 //                av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5221             }else{
5222                 s->avctx->time_base= (AVRational){1001, 30000};
5223             }
5224         }
5225
5226         if(s->custom_pcf){
5227             skip_bits(&s->gb, 2); //extended Temporal reference
5228         }
5229
5230         if (ufep) {
5231             if (s->umvplus) {
5232                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5233                     skip_bits1(&s->gb);
5234             }
5235             if(s->h263_slice_structured){
5236                 if (get_bits1(&s->gb) != 0) {
5237                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5238                 }
5239                 if (get_bits1(&s->gb) != 0) {
5240                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5241                 }
5242             }
5243         }
5244
5245         s->qscale = get_bits(&s->gb, 5);
5246     }
5247
5248     s->mb_width = (s->width  + 15) / 16;
5249     s->mb_height = (s->height  + 15) / 16;
5250     s->mb_num = s->mb_width * s->mb_height;
5251
5252     /* PEI */
5253     while (get_bits1(&s->gb) != 0) {
5254         skip_bits(&s->gb, 8);
5255     }
5256
5257     if(s->h263_slice_structured){
5258         if (get_bits1(&s->gb) != 1) {
5259             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5260             return -1;
5261         }
5262
5263         ff_h263_decode_mba(s);
5264
5265         if (get_bits1(&s->gb) != 1) {
5266             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5267             return -1;
5268         }
5269     }
5270     s->f_code = 1;
5271
5272     if(s->h263_aic){
5273          s->y_dc_scale_table=
5274          s->c_dc_scale_table= ff_aic_dc_scale_table;
5275     }else{
5276         s->y_dc_scale_table=
5277         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5278     }
5279
5280      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5281          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",
5282          s->qscale, av_get_pict_type_char(s->pict_type),
5283          s->gb.size_in_bits, 1-s->no_rounding,
5284          s->obmc ? " AP" : "",
5285          s->umvplus ? " UMV" : "",
5286          s->h263_long_vectors ? " LONG" : "",
5287          s->h263_plus ? " +" : "",
5288          s->h263_aic ? " AIC" : "",
5289          s->alt_inter_vlc ? " AIV" : "",
5290          s->modified_quant ? " MQ" : "",
5291          s->loop_filter ? " LOOP" : "",
5292          s->h263_slice_structured ? " SS" : "",
5293          s->avctx->time_base.den, s->avctx->time_base.num
5294          );
5295      }
5296 #if 1
5297     if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5298         int i,j;
5299         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5300         av_log(s->avctx, AV_LOG_DEBUG, "\n");
5301         for(i=0; i<13; i++){
5302             for(j=0; j<3; j++){
5303                 int v= get_bits(&s->gb, 8);
5304                 v |= get_sbits(&s->gb, 8)<<8;
5305                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5306             }
5307             av_log(s->avctx, AV_LOG_DEBUG, "\n");
5308         }
5309         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5310     }
5311 #endif
5312
5313     return 0;
5314 }
5315
5316 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5317 {
5318     int i;
5319     int a= 2<<s->sprite_warping_accuracy;
5320     int rho= 3-s->sprite_warping_accuracy;
5321     int r=16/a;
5322     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5323     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5324     int sprite_ref[4][2];
5325     int virtual_ref[2][2];
5326     int w2, h2, w3, h3;
5327     int alpha=0, beta=0;
5328     int w= s->width;
5329     int h= s->height;
5330     int min_ab;
5331
5332     for(i=0; i<s->num_sprite_warping_points; i++){
5333         int length;
5334         int x=0, y=0;
5335
5336         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5337         if(length){
5338             x= get_xbits(gb, length);
5339         }
5340         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5341
5342         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5343         if(length){
5344             y=get_xbits(gb, length);
5345         }
5346         skip_bits1(gb); /* marker bit */
5347 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5348         d[i][0]= x;
5349         d[i][1]= y;
5350     }
5351
5352     while((1<<alpha)<w) alpha++;
5353     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5354     w2= 1<<alpha;
5355     h2= 1<<beta;
5356
5357 // Note, the 4th point isn't used for GMC
5358     if(s->divx_version==500 && s->divx_build==413){
5359         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5360         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5361         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5362         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5363         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5364         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5365     } else {
5366         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5367         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5368         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5369         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5370         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5371         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5372     }
5373 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5374     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5375
5376 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5377 // perhaps it should be reordered to be more readable ...
5378 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5379 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5380     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5381         + 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);
5382     virtual_ref[0][1]= 16*vop_ref[0][1]
5383         + 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);
5384     virtual_ref[1][0]= 16*vop_ref[0][0]
5385         + 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);
5386     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5387         + 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);
5388
5389     switch(s->num_sprite_warping_points)
5390     {
5391         case 0:
5392             s->sprite_offset[0][0]= 0;
5393             s->sprite_offset[0][1]= 0;
5394             s->sprite_offset[1][0]= 0;
5395             s->sprite_offset[1][1]= 0;
5396             s->sprite_delta[0][0]= a;
5397             s->sprite_delta[0][1]= 0;
5398             s->sprite_delta[1][0]= 0;
5399             s->sprite_delta[1][1]= a;
5400             s->sprite_shift[0]= 0;
5401             s->sprite_shift[1]= 0;
5402             break;
5403         case 1: //GMC only
5404             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5405             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5406             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5407             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5408             s->sprite_delta[0][0]= a;
5409             s->sprite_delta[0][1]= 0;
5410             s->sprite_delta[1][0]= 0;
5411             s->sprite_delta[1][1]= a;
5412             s->sprite_shift[0]= 0;
5413             s->sprite_shift[1]= 0;
5414             break;
5415         case 2:
5416             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5417                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5418                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5419                                                   + (1<<(alpha+rho-1));
5420             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5421                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5422                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5423                                                   + (1<<(alpha+rho-1));
5424             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5425                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5426                                      +2*w2*r*sprite_ref[0][0]
5427                                      - 16*w2
5428                                      + (1<<(alpha+rho+1)));
5429             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5430                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5431                                      +2*w2*r*sprite_ref[0][1]
5432                                      - 16*w2
5433                                      + (1<<(alpha+rho+1)));
5434             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5435             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5436             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5437             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5438
5439             s->sprite_shift[0]= alpha+rho;
5440             s->sprite_shift[1]= alpha+rho+2;
5441             break;
5442         case 3:
5443             min_ab= FFMIN(alpha, beta);
5444             w3= w2>>min_ab;
5445             h3= h2>>min_ab;
5446             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5447                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5448                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5449                                    + (1<<(alpha+beta+rho-min_ab-1));
5450             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5451                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5452                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5453                                    + (1<<(alpha+beta+rho-min_ab-1));
5454             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5455                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5456                                    + 2*w2*h3*r*sprite_ref[0][0]
5457                                    - 16*w2*h3
5458                                    + (1<<(alpha+beta+rho-min_ab+1));
5459             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5460                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5461                                    + 2*w2*h3*r*sprite_ref[0][1]
5462                                    - 16*w2*h3
5463                                    + (1<<(alpha+beta+rho-min_ab+1));
5464             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5465             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5466             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5467             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5468
5469             s->sprite_shift[0]= alpha + beta + rho - min_ab;
5470             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5471             break;
5472     }
5473     /* try to simplify the situation */
5474     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5475        && s->sprite_delta[0][1] == 0
5476        && s->sprite_delta[1][0] == 0
5477        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5478     {
5479         s->sprite_offset[0][0]>>=s->sprite_shift[0];
5480         s->sprite_offset[0][1]>>=s->sprite_shift[0];
5481         s->sprite_offset[1][0]>>=s->sprite_shift[1];
5482         s->sprite_offset[1][1]>>=s->sprite_shift[1];
5483         s->sprite_delta[0][0]= a;
5484         s->sprite_delta[0][1]= 0;
5485         s->sprite_delta[1][0]= 0;
5486         s->sprite_delta[1][1]= a;
5487         s->sprite_shift[0]= 0;
5488         s->sprite_shift[1]= 0;
5489         s->real_sprite_warping_points=1;
5490     }
5491     else{
5492         int shift_y= 16 - s->sprite_shift[0];
5493         int shift_c= 16 - s->sprite_shift[1];
5494 //printf("shifts %d %d\n", shift_y, shift_c);
5495         for(i=0; i<2; i++){
5496             s->sprite_offset[0][i]<<= shift_y;
5497             s->sprite_offset[1][i]<<= shift_c;
5498             s->sprite_delta[0][i]<<= shift_y;
5499             s->sprite_delta[1][i]<<= shift_y;
5500             s->sprite_shift[i]= 16;
5501         }
5502         s->real_sprite_warping_points= s->num_sprite_warping_points;
5503     }
5504 #if 0
5505 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5506     vop_ref[0][0], vop_ref[0][1],
5507     vop_ref[1][0], vop_ref[1][1],
5508     vop_ref[2][0], vop_ref[2][1],
5509     sprite_ref[0][0], sprite_ref[0][1],
5510     sprite_ref[1][0], sprite_ref[1][1],
5511     sprite_ref[2][0], sprite_ref[2][1],
5512     virtual_ref[0][0], virtual_ref[0][1],
5513     virtual_ref[1][0], virtual_ref[1][1]
5514     );
5515
5516 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5517     s->sprite_offset[0][0], s->sprite_offset[0][1],
5518     s->sprite_delta[0][0], s->sprite_delta[0][1],
5519     s->sprite_delta[1][0], s->sprite_delta[1][1],
5520     s->sprite_shift[0]
5521     );
5522 #endif
5523 }
5524
5525 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5526     int hours, minutes, seconds;
5527
5528     hours= get_bits(gb, 5);
5529     minutes= get_bits(gb, 6);
5530     skip_bits1(gb);
5531     seconds= get_bits(gb, 6);
5532
5533     s->time_base= seconds + 60*(minutes + 60*hours);
5534
5535     skip_bits1(gb);
5536     skip_bits1(gb);
5537
5538     return 0;
5539 }
5540
5541 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5542     int width, height, vo_ver_id;
5543
5544     /* vol header */
5545     skip_bits(gb, 1); /* random access */
5546     s->vo_type= get_bits(gb, 8);
5547     if (get_bits1(gb) != 0) { /* is_ol_id */
5548         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5549         skip_bits(gb, 3); /* vo_priority */
5550     } else {
5551         vo_ver_id = 1;
5552     }
5553 //printf("vo type:%d\n",s->vo_type);
5554     s->aspect_ratio_info= get_bits(gb, 4);
5555     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5556         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5557         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5558     }else{
5559         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5560     }
5561
5562     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5563         int chroma_format= get_bits(gb, 2);
5564         if(chroma_format!=1){
5565             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5566         }
5567         s->low_delay= get_bits1(gb);
5568         if(get_bits1(gb)){ /* vbv parameters */
5569             get_bits(gb, 15);   /* first_half_bitrate */
5570             skip_bits1(gb);     /* marker */
5571             get_bits(gb, 15);   /* latter_half_bitrate */
5572             skip_bits1(gb);     /* marker */
5573             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
5574             skip_bits1(gb);     /* marker */
5575             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
5576             get_bits(gb, 11);   /* first_half_vbv_occupancy */
5577             skip_bits1(gb);     /* marker */
5578             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
5579             skip_bits1(gb);     /* marker */
5580         }
5581     }else{
5582         // set low delay flag only once the smartest? low delay detection won't be overriden
5583         if(s->picture_number==0)
5584             s->low_delay=0;
5585     }
5586
5587     s->shape = get_bits(gb, 2); /* vol shape */
5588     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5589     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5590         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5591         skip_bits(gb, 4);  //video_object_layer_shape_extension
5592     }
5593
5594     check_marker(gb, "before time_increment_resolution");
5595
5596     s->avctx->time_base.den = get_bits(gb, 16);
5597     if(!s->avctx->time_base.den){
5598         av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5599         return -1;
5600     }
5601
5602     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5603     if (s->time_increment_bits < 1)
5604         s->time_increment_bits = 1;
5605
5606     check_marker(gb, "before fixed_vop_rate");
5607
5608     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
5609         s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5610     }else
5611         s->avctx->time_base.num = 1;
5612
5613     s->t_frame=0;
5614
5615     if (s->shape != BIN_ONLY_SHAPE) {
5616         if (s->shape == RECT_SHAPE) {
5617             skip_bits1(gb);   /* marker */
5618             width = get_bits(gb, 13);
5619             skip_bits1(gb);   /* marker */
5620             height = get_bits(gb, 13);
5621             skip_bits1(gb);   /* marker */
5622             if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5623                 s->width = width;
5624                 s->height = height;
5625 //                printf("width/height: %d %d\n", width, height);
5626             }
5627         }
5628
5629         s->progressive_sequence=
5630         s->progressive_frame= get_bits1(gb)^1;
5631         s->interlaced_dct=0;
5632         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5633             av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
5634         if (vo_ver_id == 1) {
5635             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5636         } else {
5637             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5638         }
5639         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5640         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5641             if(s->vol_sprite_usage==STATIC_SPRITE){
5642                 s->sprite_width = get_bits(gb, 13);
5643                 skip_bits1(gb); /* marker */
5644                 s->sprite_height= get_bits(gb, 13);
5645                 skip_bits1(gb); /* marker */
5646                 s->sprite_left  = get_bits(gb, 13);
5647                 skip_bits1(gb); /* marker */
5648                 s->sprite_top   = get_bits(gb, 13);
5649                 skip_bits1(gb); /* marker */
5650             }
5651             s->num_sprite_warping_points= get_bits(gb, 6);
5652             s->sprite_warping_accuracy = get_bits(gb, 2);
5653             s->sprite_brightness_change= get_bits1(gb);
5654             if(s->vol_sprite_usage==STATIC_SPRITE)
5655                 s->low_latency_sprite= get_bits1(gb);
5656         }
5657         // FIXME sadct disable bit if verid!=1 && shape not rect
5658
5659         if (get_bits1(gb) == 1) {   /* not_8_bit */
5660             s->quant_precision = get_bits(gb, 4); /* quant_precision */
5661             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5662             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5663         } else {
5664             s->quant_precision = 5;
5665         }
5666
5667         // FIXME a bunch of grayscale shape things
5668
5669         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5670             int i, v;
5671
5672             /* load default matrixes */
5673             for(i=0; i<64; i++){
5674                 int j= s->dsp.idct_permutation[i];
5675                 v= ff_mpeg4_default_intra_matrix[i];
5676                 s->intra_matrix[j]= v;
5677                 s->chroma_intra_matrix[j]= v;
5678
5679                 v= ff_mpeg4_default_non_intra_matrix[i];
5680                 s->inter_matrix[j]= v;
5681                 s->chroma_inter_matrix[j]= v;
5682             }
5683
5684             /* load custom intra matrix */
5685             if(get_bits1(gb)){
5686                 int last=0;
5687                 for(i=0; i<64; i++){
5688                     int j;
5689                     v= get_bits(gb, 8);
5690                     if(v==0) break;
5691
5692                     last= v;
5693                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5694                     s->intra_matrix[j]= v;
5695                     s->chroma_intra_matrix[j]= v;
5696                 }
5697
5698                 /* replicate last value */
5699                 for(; i<64; i++){
5700                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5701                     s->intra_matrix[j]= last;
5702                     s->chroma_intra_matrix[j]= last;
5703                 }
5704             }
5705
5706             /* load custom non intra matrix */
5707             if(get_bits1(gb)){
5708                 int last=0;
5709                 for(i=0; i<64; i++){
5710                     int j;
5711                     v= get_bits(gb, 8);
5712                     if(v==0) break;
5713
5714                     last= v;
5715                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5716                     s->inter_matrix[j]= v;
5717                     s->chroma_inter_matrix[j]= v;
5718                 }
5719
5720                 /* replicate last value */
5721                 for(; i<64; i++){
5722                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5723                     s->inter_matrix[j]= last;
5724                     s->chroma_inter_matrix[j]= last;
5725                 }
5726             }
5727
5728             // FIXME a bunch of grayscale shape things
5729         }
5730
5731         if(vo_ver_id != 1)
5732              s->quarter_sample= get_bits1(gb);
5733         else s->quarter_sample=0;
5734
5735         if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5736
5737         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5738
5739         s->data_partitioning= get_bits1(gb);
5740         if(s->data_partitioning){
5741             s->rvlc= get_bits1(gb);
5742         }
5743
5744         if(vo_ver_id != 1) {
5745             s->new_pred= get_bits1(gb);
5746             if(s->new_pred){
5747                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5748                 skip_bits(gb, 2); /* requested upstream message type */
5749                 skip_bits1(gb); /* newpred segment type */
5750             }
5751             s->reduced_res_vop= get_bits1(gb);
5752             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5753         }
5754         else{
5755             s->new_pred=0;
5756             s->reduced_res_vop= 0;
5757         }
5758
5759         s->scalability= get_bits1(gb);
5760
5761         if (s->scalability) {
5762             GetBitContext bak= *gb;
5763             int ref_layer_id;
5764             int ref_layer_sampling_dir;
5765             int h_sampling_factor_n;
5766             int h_sampling_factor_m;
5767             int v_sampling_factor_n;
5768             int v_sampling_factor_m;
5769
5770             s->hierachy_type= get_bits1(gb);
5771             ref_layer_id= get_bits(gb, 4);
5772             ref_layer_sampling_dir= get_bits1(gb);
5773             h_sampling_factor_n= get_bits(gb, 5);
5774             h_sampling_factor_m= get_bits(gb, 5);
5775             v_sampling_factor_n= get_bits(gb, 5);
5776             v_sampling_factor_m= get_bits(gb, 5);
5777             s->enhancement_type= get_bits1(gb);
5778
5779             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
5780                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5781
5782 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5783                 s->scalability=0;
5784
5785                 *gb= bak;
5786             }else
5787                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5788
5789             // bin shape stuff FIXME
5790         }
5791     }
5792     return 0;
5793 }
5794
5795 /**
5796  * decodes the user data stuff in the header.
5797  * allso inits divx/xvid/lavc_version/build
5798  */
5799 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5800     char buf[256];
5801     int i;
5802     int e;
5803     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5804     char last;
5805
5806     for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5807         if(show_bits(gb, 23) == 0) break;
5808         buf[i]= get_bits(gb, 8);
5809     }
5810     buf[i]=0;
5811
5812     /* divx detection */
5813     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5814     if(e<2)
5815         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5816     if(e>=2){
5817         s->divx_version= ver;
5818         s->divx_build= build;
5819         s->divx_packed= e==3 && last=='p';
5820     }
5821
5822     /* ffmpeg detection */
5823     e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5824     if(e!=4)
5825         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5826     if(e!=4){
5827         e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5828         if (e>1)
5829             build= (ver<<16) + (ver2<<8) + ver3;
5830     }
5831     if(e!=4){
5832         if(strcmp(buf, "ffmpeg")==0){
5833             s->lavc_build= 4600;
5834         }
5835     }
5836     if(e==4){
5837         s->lavc_build= build;
5838     }
5839
5840     /* xvid detection */
5841     e=sscanf(buf, "XviD%d", &build);
5842     if(e==1){
5843         s->xvid_build= build;
5844     }
5845
5846 //printf("User Data: %s\n", buf);
5847     return 0;
5848 }
5849
5850 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5851     int time_incr, time_increment;
5852
5853     s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
5854     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5855         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5856         s->low_delay=0;
5857     }
5858
5859     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5860     if(s->partitioned_frame)
5861         s->decode_mb= mpeg4_decode_partitioned_mb;
5862     else
5863         s->decode_mb= ff_mpeg4_decode_mb;
5864
5865     time_incr=0;
5866     while (get_bits1(gb) != 0)
5867         time_incr++;
5868
5869     check_marker(gb, "before time_increment");
5870
5871     if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5872         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5873
5874         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5875             if(show_bits(gb, s->time_increment_bits+1)&1) break;
5876         }
5877
5878         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5879     }
5880
5881     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5882     else time_increment= get_bits(gb, s->time_increment_bits);
5883
5884 //    printf("%d %X\n", s->time_increment_bits, time_increment);
5885 //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);
5886     if(s->pict_type!=B_TYPE){
5887         s->last_time_base= s->time_base;
5888         s->time_base+= time_incr;
5889         s->time= s->time_base*s->avctx->time_base.den + time_increment;
5890         if(s->workaround_bugs&FF_BUG_UMP4){
5891             if(s->time < s->last_non_b_time){
5892 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5893                 s->time_base++;
5894                 s->time+= s->avctx->time_base.den;
5895             }
5896         }
5897         s->pp_time= s->time - s->last_non_b_time;
5898         s->last_non_b_time= s->time;
5899     }else{
5900         s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5901         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5902         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5903 //            printf("messed up order, maybe after seeking? skipping current b frame\n");
5904             return FRAME_SKIPPED;
5905         }
5906         ff_mpeg4_init_direct_mv(s);
5907
5908         if(s->t_frame==0) s->t_frame= s->pb_time;
5909         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5910         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5911                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5912         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
5913                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5914     }
5915 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld 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);
5916
5917     if(s->avctx->time_base.num)
5918         s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5919     else
5920         s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5921     if(s->avctx->debug&FF_DEBUG_PTS)
5922         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5923
5924     check_marker(gb, "before vop_coded");
5925
5926     /* vop coded */
5927     if (get_bits1(gb) != 1){
5928         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5929             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5930         return FRAME_SKIPPED;
5931     }
5932 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5933 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5934     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5935                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5936         /* rounding type for motion estimation */
5937         s->no_rounding = get_bits1(gb);
5938     } else {
5939         s->no_rounding = 0;
5940     }
5941 //FIXME reduced res stuff
5942
5943      if (s->shape != RECT_SHAPE) {
5944          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5945              int width, height, hor_spat_ref, ver_spat_ref;
5946
5947              width = get_bits(gb, 13);
5948              skip_bits1(gb);   /* marker */
5949              height = get_bits(gb, 13);
5950              skip_bits1(gb);   /* marker */
5951              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5952              skip_bits1(gb);   /* marker */
5953              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5954          }
5955          skip_bits1(gb); /* change_CR_disable */
5956
5957          if (get_bits1(gb) != 0) {
5958              skip_bits(gb, 8); /* constant_alpha_value */
5959          }
5960      }
5961 //FIXME complexity estimation stuff
5962
5963      if (s->shape != BIN_ONLY_SHAPE) {
5964          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5965          if(!s->progressive_sequence){
5966              s->top_field_first= get_bits1(gb);
5967              s->alternate_scan= get_bits1(gb);
5968          }else
5969              s->alternate_scan= 0;
5970      }
5971
5972      if(s->alternate_scan){
5973          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
5974          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
5975          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5976          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5977      } else{
5978          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
5979          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
5980          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5981          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5982      }
5983
5984      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5985          mpeg4_decode_sprite_trajectory(s, gb);
5986          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5987          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5988      }
5989
5990      if (s->shape != BIN_ONLY_SHAPE) {
5991          s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5992          if(s->qscale==0){
5993              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5994              return -1; // makes no sense to continue, as there is nothing left from the image then
5995          }
5996
5997          if (s->pict_type != I_TYPE) {
5998              s->f_code = get_bits(gb, 3);       /* fcode_for */
5999              if(s->f_code==0){
6000                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
6001                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
6002              }
6003          }else
6004              s->f_code=1;
6005
6006          if (s->pict_type == B_TYPE) {
6007              s->b_code = get_bits(gb, 3);
6008          }else
6009              s->b_code=1;
6010
6011          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6012              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",
6013                  s->qscale, s->f_code, s->b_code,
6014                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6015                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6016                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6017                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6018          }
6019
6020          if(!s->scalability){
6021              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6022                  skip_bits1(gb); // vop shape coding type
6023              }
6024          }else{
6025              if(s->enhancement_type){
6026                  int load_backward_shape= get_bits1(gb);
6027                  if(load_backward_shape){
6028                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6029                  }
6030              }
6031              skip_bits(gb, 2); //ref_select_code
6032          }
6033      }
6034      /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6035      // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6036      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6037          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6038          s->low_delay=1;
6039      }
6040
6041      s->picture_number++; // better than pic number==0 always ;)
6042
6043      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6044      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6045
6046      if(s->workaround_bugs&FF_BUG_EDGE){
6047          s->h_edge_pos= s->width;
6048          s->v_edge_pos= s->height;
6049      }
6050      return 0;
6051 }
6052
6053 /**
6054  * decode mpeg4 headers
6055  * @return <0 if no VOP found (or a damaged one)
6056  *         FRAME_SKIPPED if a not coded VOP is found
6057  *         0 if a VOP is found
6058  */
6059 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6060 {
6061     int startcode, v;
6062
6063     /* search next start code */
6064     align_get_bits(gb);
6065
6066     if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6067         skip_bits(gb, 24);
6068         if(get_bits(gb, 8) == 0xF0)
6069             return decode_vop_header(s, gb);
6070     }
6071
6072     startcode = 0xff;
6073     for(;;) {
6074         if(get_bits_count(gb) >= gb->size_in_bits){
6075             if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6076                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6077                 return FRAME_SKIPPED; //divx bug
6078             }else
6079                 return -1; //end of stream
6080         }
6081
6082         /* use the bits after the test */
6083         v = get_bits(gb, 8);
6084         startcode = ((startcode << 8) | v) & 0xffffffff;
6085
6086         if((startcode&0xFFFFFF00) != 0x100)
6087             continue; //no startcode
6088
6089         if(s->avctx->debug&FF_DEBUG_STARTCODE){
6090             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6091             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6092             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6093             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6094             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6095             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6096             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6097             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6098             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6099             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6100             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6101             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6102             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6103             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6104             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6105             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6106             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6107             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6108             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6109             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6110             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6111             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6112             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6113             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6114             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6115             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6116             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6117             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6118             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6119         }
6120
6121         if(startcode >= 0x120 && startcode <= 0x12F){
6122             if(decode_vol_header(s, gb) < 0)
6123                 return -1;
6124         }
6125         else if(startcode == USER_DATA_STARTCODE){
6126             decode_user_data(s, gb);
6127         }
6128         else if(startcode == GOP_STARTCODE){
6129             mpeg4_decode_gop_header(s, gb);
6130         }
6131         else if(startcode == VOP_STARTCODE){
6132             return decode_vop_header(s, gb);
6133         }
6134
6135         align_get_bits(gb);
6136         startcode = 0xff;
6137     }
6138 }
6139
6140 /* don't understand why they choose a different header ! */
6141 int intel_h263_decode_picture_header(MpegEncContext *s)
6142 {
6143     int format;
6144
6145     /* picture header */
6146     if (get_bits_long(&s->gb, 22) != 0x20) {
6147         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6148         return -1;
6149     }
6150     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6151
6152     if (get_bits1(&s->gb) != 1) {
6153         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6154         return -1;      /* marker */
6155     }
6156     if (get_bits1(&s->gb) != 0) {
6157         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6158         return -1;      /* h263 id */
6159     }
6160     skip_bits1(&s->gb);         /* split screen off */
6161     skip_bits1(&s->gb);         /* camera  off */
6162     skip_bits1(&s->gb);         /* freeze picture release off */
6163
6164     format = get_bits(&s->gb, 3);
6165     if (format != 7) {
6166         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6167         return -1;
6168     }
6169     s->h263_plus = 0;
6170
6171     s->pict_type = I_TYPE + get_bits1(&s->gb);
6172
6173     s->unrestricted_mv = get_bits1(&s->gb);
6174     s->h263_long_vectors = s->unrestricted_mv;
6175
6176     if (get_bits1(&s->gb) != 0) {
6177         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6178         return -1;      /* SAC: off */
6179     }
6180     if (get_bits1(&s->gb) != 0) {
6181         s->obmc= 1;
6182         av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6183 //        return -1;      /* advanced prediction mode: off */
6184     }
6185     if (get_bits1(&s->gb) != 0) {
6186         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6187         return -1;      /* PB frame mode */
6188     }
6189
6190     /* skip unknown header garbage */
6191     skip_bits(&s->gb, 41);
6192
6193     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6194     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6195
6196     /* PEI */
6197     while (get_bits1(&s->gb) != 0) {
6198         skip_bits(&s->gb, 8);
6199     }
6200     s->f_code = 1;
6201
6202     s->y_dc_scale_table=
6203     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6204
6205     return 0;
6206 }
6207
6208 int flv_h263_decode_picture_header(MpegEncContext *s)
6209 {
6210     int format, width, height;
6211
6212     /* picture header */
6213     if (get_bits_long(&s->gb, 17) != 1) {
6214         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6215         return -1;
6216     }
6217     format = get_bits(&s->gb, 5);
6218     if (format != 0 && format != 1) {
6219         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6220         return -1;
6221     }
6222     s->h263_flv = format+1;
6223     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6224     format = get_bits(&s->gb, 3);
6225     switch (format) {
6226     case 0:
6227         width = get_bits(&s->gb, 8);
6228         height = get_bits(&s->gb, 8);
6229         break;
6230     case 1:
6231         width = get_bits(&s->gb, 16);
6232         height = get_bits(&s->gb, 16);
6233         break;
6234     case 2:
6235         width = 352;
6236         height = 288;
6237         break;
6238     case 3:
6239         width = 176;
6240         height = 144;
6241         break;
6242     case 4:
6243         width = 128;
6244         height = 96;
6245         break;
6246     case 5:
6247         width = 320;
6248         height = 240;
6249         break;
6250     case 6:
6251         width = 160;
6252         height = 120;
6253         break;
6254     default:
6255         width = height = 0;
6256         break;
6257     }
6258     if(avcodec_check_dimensions(s->avctx, width, height))
6259         return -1;
6260     s->width = width;
6261     s->height = height;
6262
6263     s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6264     s->dropable= s->pict_type > P_TYPE;
6265     if (s->dropable)
6266         s->pict_type = P_TYPE;
6267
6268     skip_bits1(&s->gb); /* deblocking flag */
6269     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6270
6271     s->h263_plus = 0;
6272
6273     s->unrestricted_mv = 1;
6274     s->h263_long_vectors = 0;
6275
6276     /* PEI */
6277     while (get_bits1(&s->gb) != 0) {
6278         skip_bits(&s->gb, 8);
6279     }
6280     s->f_code = 1;
6281
6282     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6283         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6284                s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6285     }
6286
6287     s->y_dc_scale_table=
6288     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6289
6290     return 0;
6291 }