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