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