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

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