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 */
 251         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
 252         put_bits(&s->pb, 5, s->qscale);
 253         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
 254     } else {
 255         int ufep=1;
 256         /* H.263v2 */
 257         /* H.263 Plus PTYPE */
 258
 259         put_bits(&s->pb, 3, 7);
 260         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
 261         if (format == 7)
 262             put_bits(&s->pb,3,6); /* Custom Source Format */
 263         else
 264             put_bits(&s->pb, 3, format);
 265
 266         put_bits(&s->pb,1, s->custom_pcf);
 267         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
 268         put_bits(&s->pb,1,0); /* SAC: off */
 269         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
 270         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 271         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
 272         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
 273         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 274         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 275         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
 276         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
 277         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 278         put_bits(&s->pb,3,0); /* Reserved */
 279
 280         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
 281
 282         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 283         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 284         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 285         put_bits(&s->pb,2,0); /* Reserved */
 286         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 287
 288         /* This should be here if PLUSPTYPE */
 289         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 290
 291                 if (format == 7) {
 292             /* Custom Picture Format (CPFMT) */
 293             aspect_to_info(s, s->avctx->sample_aspect_ratio);
 294
 295             put_bits(&s->pb,4,s->aspect_ratio_info);
 296             put_bits(&s->pb,9,(s->width >> 2) - 1);
 297             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 298             put_bits(&s->pb,9,(s->height >> 2));
 299             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
 300                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
 301                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
 302             }
 303         }
 304         if(s->custom_pcf){
 305             if(ufep){
 306                 put_bits(&s->pb, 1, best_clock_code);
 307                 put_bits(&s->pb, 7, best_divisor);
 308             }
 309             put_bits(&s->pb, 2, (temp_ref>>8)&3);
 310         }
 311
 312         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 313         if (s->umvplus)
 314 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 315 //FIXME check actual requested range
 316             put_bits(&s->pb,2,1); /* unlimited */
 317         if(s->h263_slice_structured)
 318             put_bits(&s->pb,2,0); /* no weird submodes */
 319
 320         put_bits(&s->pb, 5, s->qscale);
 321     }
 322
 323     put_bits(&s->pb, 1, 0);     /* no PEI */
 324
 325     if(s->h263_slice_structured){
 326         put_bits(&s->pb, 1, 1);
 327
 328         assert(s->mb_x == 0 && s->mb_y == 0);
 329         ff_h263_encode_mba(s);
 330
 331         put_bits(&s->pb, 1, 1);
 332     }
 333
 334     if(s->h263_aic){
 335          s->y_dc_scale_table=
 336          s->c_dc_scale_table= ff_aic_dc_scale_table;
 337     }else{
 338         s->y_dc_scale_table=
 339         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 340     }
 341 }
 342
 343 /**
 344  * Encodes a group of blocks header.
 345  */
 346 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
 347 {
 348     put_bits(&s->pb, 17, 1); /* GBSC */
 349
 350     if(s->h263_slice_structured){
 351         put_bits(&s->pb, 1, 1);
 352
 353         ff_h263_encode_mba(s);
 354
 355         if(s->mb_num > 1583)
 356             put_bits(&s->pb, 1, 1);
 357         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 358         put_bits(&s->pb, 1, 1);
 359         put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 360     }else{
 361         int gob_number= mb_line / s->gob_index;
 362
 363         put_bits(&s->pb, 5, gob_number); /* GN */
 364         put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 365         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 366     }
 367 }
 368
 369 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
 370     int last=0;
 371     int j;
 372     int rate=0;
 373
 374     for(j=1; j<=block_last_index; j++){
 375         const int index= scantable[j];
 376         int level= block[index];
 377         if(level){
 378             level+= 64;
 379             if((level&(~127)) == 0){
 380                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
 381                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
 382             }else
 383                 rate += s->ac_esc_length;
 384             level-= 64;
 385
 386             last= j;
 387         }
 388     }
 389
 390     return rate;
 391 }
 392
 393 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
 394 {
 395     int score= 0;
 396     int i, n;
 397     int8_t * const qscale_table= s->current_picture.qscale_table;
 398
 399     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
 400
 401     for(n=0; n<6; n++){
 402         int16_t *ac_val, *ac_val1;
 403
 404         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
 405
 406         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 407         ac_val1= ac_val;
 408         if(dir[n]){
 409             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
 410             /* top prediction */
 411             ac_val-= s->block_wrap[n]*16;
 412             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
 413                 /* same qscale */
 414                 for(i=1; i<8; i++){
 415                     const int level= block[n][s->dsp.idct_permutation[i   ]];
 416                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
 417                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
 418                     ac_val1[i+8]= level;
 419                 }
 420             }else{
 421                 /* different qscale, we must rescale */
 422                 for(i=1; i<8; i++){
 423                     const int level= block[n][s->dsp.idct_permutation[i   ]];
 424                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
 425                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
 426                     ac_val1[i+8]= level;
 427                 }
 428             }
 429             st[n]= s->intra_h_scantable.permutated;
 430         }else{
 431             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
 432             /* left prediction */
 433             ac_val-= 16;
 434             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
 435                 /* same qscale */
 436                 for(i=1; i<8; i++){
 437                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
 438                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
 439                     ac_val1[i  ]= level;
 440                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
 441                 }
 442             }else{
 443                 /* different qscale, we must rescale */
 444                 for(i=1; i<8; i++){
 445                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
 446                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
 447                     ac_val1[i  ]= level;
 448                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
 449                 }
 450             }
 451             st[n]= s->intra_v_scantable.permutated;
 452         }
 453
 454         for(i=63; i>0; i--) //FIXME optimize
 455             if(block[n][ st[n][i] ]) break;
 456         s->block_last_index[n]= i;
 457
 458         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
 459     }
 460
 461     return score < 0;
 462 }
 463
 464 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
 465 {
 466     int i, n;
 467     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
 468
 469     for(n=0; n<6; n++){
 470         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 471
 472         st[n]= s->intra_scantable.permutated;
 473         if(dir[n]){
 474             /* top prediction */
 475             for(i=1; i<8; i++){
 476                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
 477             }
 478         }else{
 479             /* left prediction */
 480             for(i=1; i<8; i++){
 481                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
 482             }
 483         }
 484     }
 485 }
 486
 487 /**
 488  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 489  */
 490 void ff_clean_h263_qscales(MpegEncContext *s){
 491     int i;
 492     int8_t * const qscale_table= s->current_picture.qscale_table;
 493
 494     for(i=1; i<s->mb_num; i++){
 495         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
 496             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
 497     }
 498     for(i=s->mb_num-2; i>=0; i--){
 499         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
 500             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
 501     }
 502
 503     if(s->codec_id != CODEC_ID_H263P){
 504         for(i=1; i<s->mb_num; i++){
 505             int mb_xy= s->mb_index2xy[i];
 506
 507             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
 508                 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
 509                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
 510             }
 511         }
 512     }
 513 }
 514
 515 /**
 516  * modify mb_type & qscale so that encoding is acually possible in mpeg4
 517  */
 518 void ff_clean_mpeg4_qscales(MpegEncContext *s){
 519     int i;
 520     int8_t * const qscale_table= s->current_picture.qscale_table;
 521
 522     ff_clean_h263_qscales(s);
 523
 524     if(s->pict_type== B_TYPE){
 525         int odd=0;
 526         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
 527
 528         for(i=0; i<s->mb_num; i++){
 529             int mb_xy= s->mb_index2xy[i];
 530             odd += qscale_table[mb_xy]&1;
 531         }
 532
 533         if(2*odd > s->mb_num) odd=1;
 534         else                  odd=0;
 535
 536         for(i=0; i<s->mb_num; i++){
 537             int mb_xy= s->mb_index2xy[i];
 538             if((qscale_table[mb_xy]&1) != odd)
 539                 qscale_table[mb_xy]++;
 540             if(qscale_table[mb_xy] > 31)
 541                 qscale_table[mb_xy]= 31;
 542         }
 543
 544         for(i=1; i<s->mb_num; i++){
 545             int mb_xy= s->mb_index2xy[i];
 546             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
 547                 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
 548                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
 549             }
 550         }
 551     }
 552 }
 553
 554 #endif //CONFIG_ENCODERS
 555 /**
 556  *
 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         ff_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 < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2412                 mpeg4_encode_visual_object_header(s);
2413             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || 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     assert(s->time>=0);
2429     time_div= s->time/s->avctx->time_base.den;
2430     time_mod= s->time%s->avctx->time_base.den;
2431     time_incr= time_div - s->last_time_base;
2432     assert(time_incr >= 0);
2433     while(time_incr--)
2434         put_bits(&s->pb, 1, 1);
2435
2436     put_bits(&s->pb, 1, 0);
2437
2438     put_bits(&s->pb, 1, 1);                             /* marker */
2439     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2440     put_bits(&s->pb, 1, 1);                             /* marker */
2441     put_bits(&s->pb, 1, 1);                             /* vop coded */
2442     if (    s->pict_type == P_TYPE
2443         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2444         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2445     }
2446     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2447     if(!s->progressive_sequence){
2448          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2449          put_bits(&s->pb, 1, s->alternate_scan);
2450     }
2451     //FIXME sprite stuff
2452
2453     put_bits(&s->pb, 5, s->qscale);
2454
2455     if (s->pict_type != I_TYPE)
2456         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2457     if (s->pict_type == B_TYPE)
2458         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2459     //    printf("****frame %d\n", picture_number);
2460 }
2461
2462 #endif //CONFIG_ENCODERS
2463
2464 /**
2465  * set qscale and update qscale dependant variables.
2466  */
2467 void ff_set_qscale(MpegEncContext * s, int qscale)
2468 {
2469     if (qscale < 1)
2470         qscale = 1;
2471     else if (qscale > 31)
2472         qscale = 31;
2473
2474     s->qscale = qscale;
2475     s->chroma_qscale= s->chroma_qscale_table[qscale];
2476
2477     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2478     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2479 }
2480
2481 /**
2482  * predicts the dc.
2483  * encoding quantized level -> quantized diff
2484  * decoding quantized diff -> quantized level
2485  * @param n block index (0-3 are luma, 4-5 are chroma)
2486  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2487  */
2488 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2489 {
2490     int a, b, c, wrap, pred, scale, ret;
2491     uint16_t *dc_val;
2492
2493     /* find prediction */
2494     if (n < 4) {
2495         scale = s->y_dc_scale;
2496     } else {
2497         scale = s->c_dc_scale;
2498     }
2499     if(IS_3IV1)
2500         scale= 8;
2501
2502     wrap= s->block_wrap[n];
2503     dc_val = s->dc_val[0] + s->block_index[n];
2504
2505     /* B C
2506      * A X
2507      */
2508     a = dc_val[ - 1];
2509     b = dc_val[ - 1 - wrap];
2510     c = dc_val[ - wrap];
2511
2512     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2513     if(s->first_slice_line && n!=3){
2514         if(n!=2) b=c= 1024;
2515         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2516     }
2517     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2518         if(n==0 || n==4 || n==5)
2519             b=1024;
2520     }
2521
2522     if (abs(a - b) < abs(b - c)) {
2523         pred = c;
2524         *dir_ptr = 1; /* top */
2525     } else {
2526         pred = a;
2527         *dir_ptr = 0; /* left */
2528     }
2529     /* we assume pred is positive */
2530     pred = FASTDIV((pred + (scale >> 1)), scale);
2531
2532     if(encoding){
2533         ret = level - pred;
2534     }else{
2535         level += pred;
2536         ret= level;
2537         if(s->error_resilience>=3){
2538             if(level<0){
2539                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2540                 return -1;
2541             }
2542             if(level*scale > 2048 + scale){
2543                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2544                 return -1;
2545             }
2546         }
2547     }
2548     level *=scale;
2549     if(level&(~2047)){
2550         if(level<0)
2551             level=0;
2552         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2553             level=2047;
2554     }
2555     dc_val[0]= level;
2556
2557     return ret;
2558 }
2559
2560 /**
2561  * predicts the ac.
2562  * @param n block index (0-3 are luma, 4-5 are chroma)
2563  * @param dir the ac prediction direction
2564  */
2565 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2566                    int dir)
2567 {
2568     int i;
2569     int16_t *ac_val, *ac_val1;
2570     int8_t * const qscale_table= s->current_picture.qscale_table;
2571
2572     /* find prediction */
2573     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2574     ac_val1 = ac_val;
2575     if (s->ac_pred) {
2576         if (dir == 0) {
2577             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2578             /* left prediction */
2579             ac_val -= 16;
2580
2581             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2582                 /* same qscale */
2583                 for(i=1;i<8;i++) {
2584                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2585                 }
2586             }else{
2587                 /* different qscale, we must rescale */
2588                 for(i=1;i<8;i++) {
2589                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2590                 }
2591             }
2592         } else {
2593             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2594             /* top prediction */
2595             ac_val -= 16 * s->block_wrap[n];
2596
2597             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2598                 /* same qscale */
2599                 for(i=1;i<8;i++) {
2600                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2601                 }
2602             }else{
2603                 /* different qscale, we must rescale */
2604                 for(i=1;i<8;i++) {
2605                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2606                 }
2607             }
2608         }
2609     }
2610     /* left copy */
2611     for(i=1;i<8;i++)
2612         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2613
2614     /* top copy */
2615     for(i=1;i<8;i++)
2616         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2617
2618 }
2619
2620 #ifdef CONFIG_ENCODERS
2621
2622 /**
2623  * encodes the dc value.
2624  * @param n block index (0-3 are luma, 4-5 are chroma)
2625  */
2626 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2627 {
2628 #if 1
2629 //    if(level<-255 || level>255) printf("dc overflow\n");
2630     level+=256;
2631     if (n < 4) {
2632         /* luminance */
2633         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2634     } else {
2635         /* chrominance */
2636         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2637     }
2638 #else
2639     int size, v;
2640     /* find number of bits */
2641     size = 0;
2642     v = abs(level);
2643     while (v) {
2644         v >>= 1;
2645         size++;
2646     }
2647
2648     if (n < 4) {
2649         /* luminance */
2650         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2651     } else {
2652         /* chrominance */
2653         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2654     }
2655
2656     /* encode remaining bits */
2657     if (size > 0) {
2658         if (level < 0)
2659             level = (-level) ^ ((1 << size) - 1);
2660         put_bits(&s->pb, size, level);
2661         if (size > 8)
2662             put_bits(&s->pb, 1, 1);
2663     }
2664 #endif
2665 }
2666
2667 static inline int mpeg4_get_dc_length(int level, int n){
2668     if (n < 4) {
2669         return uni_DCtab_lum_len[level + 256];
2670     } else {
2671         return uni_DCtab_chrom_len[level + 256];
2672     }
2673 }
2674
2675 /**
2676  * encodes a 8x8 block
2677  * @param n block index (0-3 are luma, 4-5 are chroma)
2678  */
2679 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2680                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2681 {
2682     int i, last_non_zero;
2683 #if 0 //variables for the outcommented version
2684     int code, sign, last;
2685 #endif
2686     const RLTable *rl;
2687     uint32_t *bits_tab;
2688     uint8_t *len_tab;
2689     const int last_index = s->block_last_index[n];
2690
2691     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2692         /* mpeg4 based DC predictor */
2693         mpeg4_encode_dc(dc_pb, intra_dc, n);
2694         if(last_index<1) return;
2695         i = 1;
2696         rl = &rl_intra;
2697         bits_tab= uni_mpeg4_intra_rl_bits;
2698         len_tab = uni_mpeg4_intra_rl_len;
2699     } else {
2700         if(last_index<0) return;
2701         i = 0;
2702         rl = &rl_inter;
2703         bits_tab= uni_mpeg4_inter_rl_bits;
2704         len_tab = uni_mpeg4_inter_rl_len;
2705     }
2706
2707     /* AC coefs */
2708     last_non_zero = i - 1;
2709 #if 1
2710     for (; i < last_index; i++) {
2711         int level = block[ scan_table[i] ];
2712         if (level) {
2713             int run = i - last_non_zero - 1;
2714             level+=64;
2715             if((level&(~127)) == 0){
2716                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2717                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2718             }else{ //ESC3
2719                 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);
2720             }
2721             last_non_zero = i;
2722         }
2723     }
2724     /*if(i<=last_index)*/{
2725         int level = block[ scan_table[i] ];
2726         int run = i - last_non_zero - 1;
2727         level+=64;
2728         if((level&(~127)) == 0){
2729             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2730             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2731         }else{ //ESC3
2732             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);
2733         }
2734     }
2735 #else
2736     for (; i <= last_index; i++) {
2737         const int slevel = block[ scan_table[i] ];
2738         if (slevel) {
2739             int level;
2740             int run = i - last_non_zero - 1;
2741             last = (i == last_index);
2742             sign = 0;
2743             level = slevel;
2744             if (level < 0) {
2745                 sign = 1;
2746                 level = -level;
2747             }
2748             code = get_rl_index(rl, last, run, level);
2749             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2750             if (code == rl->n) {
2751                 int level1, run1;
2752                 level1 = level - rl->max_level[last][run];
2753                 if (level1 < 1)
2754                     goto esc2;
2755                 code = get_rl_index(rl, last, run, level1);
2756                 if (code == rl->n) {
2757                 esc2:
2758                     put_bits(ac_pb, 1, 1);
2759                     if (level > MAX_LEVEL)
2760                         goto esc3;
2761                     run1 = run - rl->max_run[last][level] - 1;
2762                     if (run1 < 0)
2763                         goto esc3;
2764                     code = get_rl_index(rl, last, run1, level);
2765                     if (code == rl->n) {
2766                     esc3:
2767                         /* third escape */
2768                         put_bits(ac_pb, 1, 1);
2769                         put_bits(ac_pb, 1, last);
2770                         put_bits(ac_pb, 6, run);
2771                         put_bits(ac_pb, 1, 1);
2772                         put_bits(ac_pb, 12, slevel & 0xfff);
2773                         put_bits(ac_pb, 1, 1);
2774                     } else {
2775                         /* second escape */
2776                         put_bits(ac_pb, 1, 0);
2777                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2778                         put_bits(ac_pb, 1, sign);
2779                     }
2780                 } else {
2781                     /* first escape */
2782                     put_bits(ac_pb, 1, 0);
2783                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2784                     put_bits(ac_pb, 1, sign);
2785                 }
2786             } else {
2787                 put_bits(ac_pb, 1, sign);
2788             }
2789             last_non_zero = i;
2790         }
2791     }
2792 #endif
2793 }
2794
2795 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2796                                uint8_t *scan_table)
2797 {
2798     int i, last_non_zero;
2799     const RLTable *rl;
2800     uint8_t *len_tab;
2801     const int last_index = s->block_last_index[n];
2802     int len=0;
2803
2804     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2805         /* mpeg4 based DC predictor */
2806         len += mpeg4_get_dc_length(intra_dc, n);
2807         if(last_index<1) return len;
2808         i = 1;
2809         rl = &rl_intra;
2810         len_tab = uni_mpeg4_intra_rl_len;
2811     } else {
2812         if(last_index<0) return 0;
2813         i = 0;
2814         rl = &rl_inter;
2815         len_tab = uni_mpeg4_inter_rl_len;
2816     }
2817
2818     /* AC coefs */
2819     last_non_zero = i - 1;
2820     for (; i < last_index; i++) {
2821         int level = block[ scan_table[i] ];
2822         if (level) {
2823             int run = i - last_non_zero - 1;
2824             level+=64;
2825             if((level&(~127)) == 0){
2826                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2827                 len += len_tab[index];
2828             }else{ //ESC3
2829                 len += 7+2+1+6+1+12+1;
2830             }
2831             last_non_zero = i;
2832         }
2833     }
2834     /*if(i<=last_index)*/{
2835         int level = block[ scan_table[i] ];
2836         int run = i - last_non_zero - 1;
2837         level+=64;
2838         if((level&(~127)) == 0){
2839             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2840             len += len_tab[index];
2841         }else{ //ESC3
2842             len += 7+2+1+6+1+12+1;
2843         }
2844     }
2845
2846     return len;
2847 }
2848
2849 #endif
2850
2851
2852 /***********************************************/
2853 /* decoding */
2854
2855 static VLC intra_MCBPC_vlc;
2856 static VLC inter_MCBPC_vlc;
2857 static VLC cbpy_vlc;
2858 static VLC mv_vlc;
2859 static VLC dc_lum, dc_chrom;
2860 static VLC sprite_trajectory;
2861 static VLC mb_type_b_vlc;
2862 static VLC h263_mbtype_b_vlc;
2863 static VLC cbpc_b_vlc;
2864
2865 void init_vlc_rl(RLTable *rl, int use_static)
2866 {
2867     int i, q;
2868
2869     /* Return if static table is already initialized */
2870     if(use_static && rl->rl_vlc[0])
2871         return;
2872
2873     init_vlc(&rl->vlc, 9, rl->n + 1,
2874              &rl->table_vlc[0][1], 4, 2,
2875              &rl->table_vlc[0][0], 4, 2, use_static);
2876
2877
2878     for(q=0; q<32; q++){
2879         int qmul= q*2;
2880         int qadd= (q-1)|1;
2881
2882         if(q==0){
2883             qmul=1;
2884             qadd=0;
2885         }
2886         if(use_static)
2887             rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2888         else
2889             rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2890         for(i=0; i<rl->vlc.table_size; i++){
2891             int code= rl->vlc.table[i][0];
2892             int len = rl->vlc.table[i][1];
2893             int level, run;
2894
2895             if(len==0){ // illegal code
2896                 run= 66;
2897                 level= MAX_LEVEL;
2898             }else if(len<0){ //more bits needed
2899                 run= 0;
2900                 level= code;
2901             }else{
2902                 if(code==rl->n){ //esc
2903                     run= 66;
2904                     level= 0;
2905                 }else{
2906                     run=   rl->table_run  [code] + 1;
2907                     level= rl->table_level[code] * qmul + qadd;
2908                     if(code >= rl->last) run+=192;
2909                 }
2910             }
2911             rl->rl_vlc[q][i].len= len;
2912             rl->rl_vlc[q][i].level= level;
2913             rl->rl_vlc[q][i].run= run;
2914         }
2915     }
2916 }
2917
2918 /* init vlcs */
2919
2920 /* XXX: find a better solution to handle static init */
2921 void h263_decode_init_vlc(MpegEncContext *s)
2922 {
2923     static int done = 0;
2924
2925     if (!done) {
2926         done = 1;
2927
2928         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2929                  intra_MCBPC_bits, 1, 1,
2930                  intra_MCBPC_code, 1, 1, 1);
2931         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2932                  inter_MCBPC_bits, 1, 1,
2933                  inter_MCBPC_code, 1, 1, 1);
2934         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2935                  &cbpy_tab[0][1], 2, 1,
2936                  &cbpy_tab[0][0], 2, 1, 1);
2937         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2938                  &mvtab[0][1], 2, 1,
2939                  &mvtab[0][0], 2, 1, 1);
2940         init_rl(&rl_inter, 1);
2941         init_rl(&rl_intra, 1);
2942         init_rl(&rvlc_rl_inter, 1);
2943         init_rl(&rvlc_rl_intra, 1);
2944         init_rl(&rl_intra_aic, 1);
2945         init_vlc_rl(&rl_inter, 1);
2946         init_vlc_rl(&rl_intra, 1);
2947         init_vlc_rl(&rvlc_rl_inter, 1);
2948         init_vlc_rl(&rvlc_rl_intra, 1);
2949         init_vlc_rl(&rl_intra_aic, 1);
2950         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2951                  &DCtab_lum[0][1], 2, 1,
2952                  &DCtab_lum[0][0], 2, 1, 1);
2953         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2954                  &DCtab_chrom[0][1], 2, 1,
2955                  &DCtab_chrom[0][0], 2, 1, 1);
2956         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2957                  &sprite_trajectory_tab[0][1], 4, 2,
2958                  &sprite_trajectory_tab[0][0], 4, 2, 1);
2959         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2960                  &mb_type_b_tab[0][1], 2, 1,
2961                  &mb_type_b_tab[0][0], 2, 1, 1);
2962         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2963                  &h263_mbtype_b_tab[0][1], 2, 1,
2964                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
2965         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2966                  &cbpc_b_tab[0][1], 2, 1,
2967                  &cbpc_b_tab[0][0], 2, 1, 1);
2968     }
2969 }
2970
2971 /**
2972  * Get the GOB height based on picture height.
2973  */
2974 int ff_h263_get_gob_height(MpegEncContext *s){
2975     if (s->height <= 400)
2976         return 1;
2977     else if (s->height <= 800)
2978         return  2;
2979     else
2980         return 4;
2981 }
2982
2983 int ff_h263_decode_mba(MpegEncContext *s)
2984 {
2985     int i, mb_pos;
2986
2987     for(i=0; i<6; i++){
2988         if(s->mb_num-1 <= ff_mba_max[i]) break;
2989     }
2990     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2991     s->mb_x= mb_pos % s->mb_width;
2992     s->mb_y= mb_pos / s->mb_width;
2993
2994     return mb_pos;
2995 }
2996
2997 void ff_h263_encode_mba(MpegEncContext *s)
2998 {
2999     int i, mb_pos;
3000
3001     for(i=0; i<6; i++){
3002         if(s->mb_num-1 <= ff_mba_max[i]) break;
3003     }
3004     mb_pos= s->mb_x + s->mb_width*s->mb_y;
3005     put_bits(&s->pb, ff_mba_length[i], mb_pos);
3006 }
3007
3008 /**
3009  * decodes the group of blocks header or slice header.
3010  * @return <0 if an error occured
3011  */
3012 static int h263_decode_gob_header(MpegEncContext *s)
3013 {
3014     unsigned int val, gfid, gob_number;
3015     int left;
3016
3017     /* Check for GOB Start Code */
3018     val = show_bits(&s->gb, 16);
3019     if(val)
3020         return -1;
3021
3022         /* We have a GBSC probably with GSTUFF */
3023     skip_bits(&s->gb, 16); /* Drop the zeros */
3024     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3025     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3026     for(;left>13; left--){
3027         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3028     }
3029     if(left<=13)
3030         return -1;
3031
3032     if(s->h263_slice_structured){
3033         if(get_bits1(&s->gb)==0)
3034             return -1;
3035
3036         ff_h263_decode_mba(s);
3037
3038         if(s->mb_num > 1583)
3039             if(get_bits1(&s->gb)==0)
3040                 return -1;
3041
3042         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3043         if(get_bits1(&s->gb)==0)
3044             return -1;
3045         gfid = get_bits(&s->gb, 2); /* GFID */
3046     }else{
3047         gob_number = get_bits(&s->gb, 5); /* GN */
3048         s->mb_x= 0;
3049         s->mb_y= s->gob_index* gob_number;
3050         gfid = get_bits(&s->gb, 2); /* GFID */
3051         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3052     }
3053
3054     if(s->mb_y >= s->mb_height)
3055         return -1;
3056
3057     if(s->qscale==0)
3058         return -1;
3059
3060     return 0;
3061 }
3062
3063 static inline void memsetw(short *tab, int val, int n)
3064 {
3065     int i;
3066     for(i=0;i<n;i++)
3067         tab[i] = val;
3068 }
3069
3070 #ifdef CONFIG_ENCODERS
3071
3072 void ff_mpeg4_init_partitions(MpegEncContext *s)
3073 {
3074     uint8_t *start= pbBufPtr(&s->pb);
3075     uint8_t *end= s->pb.buf_end;
3076     int size= end - start;
3077     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3078     int tex_size= (size - 2*pb_size)&(~3);
3079
3080     set_put_bits_buffer_size(&s->pb, pb_size);
3081     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3082     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3083 }
3084
3085 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3086 {
3087     const int pb2_len   = put_bits_count(&s->pb2   );
3088     const int tex_pb_len= put_bits_count(&s->tex_pb);
3089     const int bits= put_bits_count(&s->pb);
3090
3091     if(s->pict_type==I_TYPE){
3092         put_bits(&s->pb, 19, DC_MARKER);
3093         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3094         s->i_tex_bits+= tex_pb_len;
3095     }else{
3096         put_bits(&s->pb, 17, MOTION_MARKER);
3097         s->misc_bits+=17 + pb2_len;
3098         s->mv_bits+= bits - s->last_bits;
3099         s->p_tex_bits+= tex_pb_len;
3100     }
3101
3102     flush_put_bits(&s->pb2);
3103     flush_put_bits(&s->tex_pb);
3104
3105     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3106     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3107     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3108     s->last_bits= put_bits_count(&s->pb);
3109 }
3110
3111 #endif //CONFIG_ENCODERS
3112
3113 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3114     switch(s->pict_type){
3115         case I_TYPE:
3116             return 16;
3117         case P_TYPE:
3118         case S_TYPE:
3119             return s->f_code+15;
3120         case B_TYPE:
3121             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3122         default:
3123             return -1;
3124     }
3125 }
3126
3127 #ifdef CONFIG_ENCODERS
3128
3129 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3130 {
3131     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3132
3133     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3134     put_bits(&s->pb, 1, 1);
3135
3136     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3137     put_bits(&s->pb, s->quant_precision, s->qscale);
3138     put_bits(&s->pb, 1, 0); /* no HEC */
3139 }
3140
3141 #endif //CONFIG_ENCODERS
3142
3143 /**
3144  * check if the next stuff is a resync marker or the end.
3145  * @return 0 if not
3146  */
3147 static inline int mpeg4_is_resync(MpegEncContext *s){
3148     const int bits_count= get_bits_count(&s->gb);
3149
3150     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3151         return 0;
3152     }
3153
3154     if(bits_count + 8 >= s->gb.size_in_bits){
3155         int v= show_bits(&s->gb, 8);
3156         v|= 0x7F >> (7-(bits_count&7));
3157
3158         if(v==0x7F)
3159             return 1;
3160     }else{
3161         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3162             int len;
3163             GetBitContext gb= s->gb;
3164
3165             skip_bits(&s->gb, 1);
3166             align_get_bits(&s->gb);
3167
3168             for(len=0; len<32; len++){
3169                 if(get_bits1(&s->gb)) break;
3170             }
3171
3172             s->gb= gb;
3173
3174             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3175                 return 1;
3176         }
3177     }
3178     return 0;
3179 }
3180
3181 /**
3182  * decodes the next video packet.
3183  * @return <0 if something went wrong
3184  */
3185 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3186 {
3187     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188     int header_extension=0, mb_num, len;
3189
3190     /* is there enough space left for a video packet + header */
3191     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3192
3193     for(len=0; len<32; len++){
3194         if(get_bits1(&s->gb)) break;
3195     }
3196
3197     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3199         return -1;
3200     }
3201
3202     if(s->shape != RECT_SHAPE){
3203         header_extension= get_bits1(&s->gb);
3204         //FIXME more stuff here
3205     }
3206
3207     mb_num= get_bits(&s->gb, mb_num_bits);
3208     if(mb_num>=s->mb_num){
3209         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3210         return -1;
3211     }
3212     if(s->pict_type == B_TYPE){
3213         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3215     }
3216
3217     s->mb_x= mb_num % s->mb_width;
3218     s->mb_y= mb_num / s->mb_width;
3219
3220     if(s->shape != BIN_ONLY_SHAPE){
3221         int qscale= get_bits(&s->gb, s->quant_precision);
3222         if(qscale)
3223             s->chroma_qscale=s->qscale= qscale;
3224     }
3225
3226     if(s->shape == RECT_SHAPE){
3227         header_extension= get_bits1(&s->gb);
3228     }
3229     if(header_extension){
3230         int time_increment;
3231         int time_incr=0;
3232
3233         while (get_bits1(&s->gb) != 0)
3234             time_incr++;
3235
3236         check_marker(&s->gb, "before time_increment in video packed header");
3237         time_increment= get_bits(&s->gb, s->time_increment_bits);
3238         check_marker(&s->gb, "before vop_coding_type in video packed header");
3239
3240         skip_bits(&s->gb, 2); /* vop coding type */
3241         //FIXME not rect stuff here
3242
3243         if(s->shape != BIN_ONLY_SHAPE){
3244             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245 //FIXME don't just ignore everything
3246             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3248                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3249             }
3250
3251             //FIXME reduced res stuff here
3252
3253             if (s->pict_type != I_TYPE) {
3254                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3255                 if(f_code==0){
3256                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3257                 }
3258             }
3259             if (s->pict_type == B_TYPE) {
3260                 int b_code = get_bits(&s->gb, 3);
3261                 if(b_code==0){
3262                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3263                 }
3264             }
3265         }
3266     }
3267     //FIXME new-pred stuff
3268
3269 //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));
3270
3271     return 0;
3272 }
3273
3274 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3275 {
3276     int c_wrap, c_xy, l_wrap, l_xy;
3277
3278     l_wrap= s->b8_stride;
3279     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280     c_wrap= s->mb_stride;
3281     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3282
3283 #if 0
3284     /* clean DC */
3285     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3288 #endif
3289
3290     /* clean AC */
3291     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3293     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3294
3295     /* clean MV */
3296     // we can't clear the MVs as they might be needed by a b frame
3297 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299     s->last_mv[0][0][0]=
3300     s->last_mv[0][0][1]=
3301     s->last_mv[1][0][0]=
3302     s->last_mv[1][0][1]= 0;
3303 }
3304
3305 /**
3306  * decodes the group of blocks / video packet header.
3307  * @return <0 if no resync found
3308  */
3309 int ff_h263_resync(MpegEncContext *s){
3310     int left, ret;
3311
3312     if(s->codec_id==CODEC_ID_MPEG4){
3313         skip_bits1(&s->gb);
3314         align_get_bits(&s->gb);
3315     }
3316
3317     if(show_bits(&s->gb, 16)==0){
3318         if(s->codec_id==CODEC_ID_MPEG4)
3319             ret= mpeg4_decode_video_packet_header(s);
3320         else
3321             ret= h263_decode_gob_header(s);
3322         if(ret>=0)
3323             return 0;
3324     }
3325     //ok, it's not where its supposed to be ...
3326     s->gb= s->last_resync_gb;
3327     align_get_bits(&s->gb);
3328     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3329
3330     for(;left>16+1+5+5; left-=8){
3331         if(show_bits(&s->gb, 16)==0){
3332             GetBitContext bak= s->gb;
3333
3334             if(s->codec_id==CODEC_ID_MPEG4)
3335                 ret= mpeg4_decode_video_packet_header(s);
3336             else
3337                 ret= h263_decode_gob_header(s);
3338             if(ret>=0)
3339                 return 0;
3340
3341             s->gb= bak;
3342         }
3343         skip_bits(&s->gb, 8);
3344     }
3345
3346     return -1;
3347 }
3348
3349 /**
3350  * gets the average motion vector for a GMC MB.
3351  * @param n either 0 for the x component or 1 for y
3352  * @returns the average MV for a GMC MB
3353  */
3354 static inline int get_amv(MpegEncContext *s, int n){
3355     int x, y, mb_v, sum, dx, dy, shift;
3356     int len = 1 << (s->f_code + 4);
3357     const int a= s->sprite_warping_accuracy;
3358
3359     if(s->workaround_bugs & FF_BUG_AMV)
3360         len >>= s->quarter_sample;
3361
3362     if(s->real_sprite_warping_points==1){
3363         if(s->divx_version==500 && s->divx_build==413)
3364             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3365         else
3366             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3367     }else{
3368         dx= s->sprite_delta[n][0];
3369         dy= s->sprite_delta[n][1];
3370         shift= s->sprite_shift[0];
3371         if(n) dy -= 1<<(shift + a + 1);
3372         else  dx -= 1<<(shift + a + 1);
3373         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3374
3375         sum=0;
3376         for(y=0; y<16; y++){
3377             int v;
3378
3379             v= mb_v + dy*y;
3380             //XXX FIXME optimize
3381             for(x=0; x<16; x++){
3382                 sum+= v>>shift;
3383                 v+= dx;
3384             }
3385         }
3386         sum= RSHIFT(sum, a+8-s->quarter_sample);
3387     }
3388
3389     if      (sum < -len) sum= -len;
3390     else if (sum >= len) sum= len-1;
3391
3392     return sum;
3393 }
3394
3395 /**
3396  * decodes first partition.
3397  * @return number of MBs decoded or <0 if an error occured
3398  */
3399 static int mpeg4_decode_partition_a(MpegEncContext *s){
3400     int mb_num;
3401     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3402
3403     /* decode first partition */
3404     mb_num=0;
3405     s->first_slice_line=1;
3406     for(; s->mb_y<s->mb_height; s->mb_y++){
3407         ff_init_block_index(s);
3408         for(; s->mb_x<s->mb_width; s->mb_x++){
3409             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3410             int cbpc;
3411             int dir=0;
3412
3413             mb_num++;
3414             ff_update_block_index(s);
3415             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416                 s->first_slice_line=0;
3417
3418             if(s->pict_type==I_TYPE){
3419                 int i;
3420
3421                 do{
3422                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3423                         return mb_num-1;
3424                     }
3425
3426                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3427                     if (cbpc < 0){
3428                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3429                         return -1;
3430                     }
3431                 }while(cbpc == 8);
3432
3433                 s->cbp_table[xy]= cbpc & 3;
3434                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3435                 s->mb_intra = 1;
3436
3437                 if(cbpc & 4) {
3438                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3439                 }
3440                 s->current_picture.qscale_table[xy]= s->qscale;
3441
3442                 s->mbintra_table[xy]= 1;
3443                 for(i=0; i<6; i++){
3444                     int dc_pred_dir;
3445                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3446                     if(dc < 0){
3447                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3448                         return -1;
3449                     }
3450                     dir<<=1;
3451                     if(dc_pred_dir) dir|=1;
3452                 }
3453                 s->pred_dir_table[xy]= dir;
3454             }else{ /* P/S_TYPE */
3455                 int mx, my, pred_x, pred_y, bits;
3456                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457                 const int stride= s->b8_stride*2;
3458
3459 try_again:
3460                 bits= show_bits(&s->gb, 17);
3461                 if(bits==MOTION_MARKER){
3462                     return mb_num-1;
3463                 }
3464                 skip_bits1(&s->gb);
3465                 if(bits&0x10000){
3466                     /* skip mb */
3467                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3469                         mx= get_amv(s, 0);
3470                         my= get_amv(s, 1);
3471                     }else{
3472                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3473                         mx=my=0;
3474                     }
3475                     mot_val[0       ]= mot_val[2       ]=
3476                     mot_val[0+stride]= mot_val[2+stride]= mx;
3477                     mot_val[1       ]= mot_val[3       ]=
3478                     mot_val[1+stride]= mot_val[3+stride]= my;
3479
3480                     if(s->mbintra_table[xy])
3481                         ff_clean_intra_table_entries(s);
3482                     continue;
3483                 }
3484
3485                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3486                 if (cbpc < 0){
3487                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3488                     return -1;
3489                 }
3490                 if(cbpc == 20)
3491                     goto try_again;
3492
3493                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3494
3495                 s->mb_intra = ((cbpc & 4) != 0);
3496
3497                 if(s->mb_intra){
3498                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499                     s->mbintra_table[xy]= 1;
3500                     mot_val[0       ]= mot_val[2       ]=
3501                     mot_val[0+stride]= mot_val[2+stride]= 0;
3502                     mot_val[1       ]= mot_val[3       ]=
3503                     mot_val[1+stride]= mot_val[3+stride]= 0;
3504                 }else{
3505                     if(s->mbintra_table[xy])
3506                         ff_clean_intra_table_entries(s);
3507
3508                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509                         s->mcsel= get_bits1(&s->gb);
3510                     else s->mcsel= 0;
3511
3512                     if ((cbpc & 16) == 0) {
3513                         /* 16x16 motion prediction */
3514
3515                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3516                         if(!s->mcsel){
3517                             mx = h263_decode_motion(s, pred_x, s->f_code);
3518                             if (mx >= 0xffff)
3519                                 return -1;
3520
3521                             my = h263_decode_motion(s, pred_y, s->f_code);
3522                             if (my >= 0xffff)
3523                                 return -1;
3524                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3525                         } else {
3526                             mx = get_amv(s, 0);
3527                             my = get_amv(s, 1);
3528                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3529                         }
3530
3531                         mot_val[0       ]= mot_val[2       ] =
3532                         mot_val[0+stride]= mot_val[2+stride]= mx;
3533                         mot_val[1       ]= mot_val[3       ]=
3534                         mot_val[1+stride]= mot_val[3+stride]= my;
3535                     } else {
3536                         int i;
3537                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3538                         for(i=0;i<4;i++) {
3539                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540                             mx = h263_decode_motion(s, pred_x, s->f_code);
3541                             if (mx >= 0xffff)
3542                                 return -1;
3543
3544                             my = h263_decode_motion(s, pred_y, s->f_code);
3545                             if (my >= 0xffff)
3546                                 return -1;
3547                             mot_val[0] = mx;
3548                             mot_val[1] = my;
3549                         }
3550                     }
3551                 }
3552             }
3553         }
3554         s->mb_x= 0;
3555     }
3556
3557     return mb_num;
3558 }
3559
3560 /**
3561  * decode second partition.
3562  * @return <0 if an error occured
3563  */
3564 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3565     int mb_num=0;
3566     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3567
3568     s->mb_x= s->resync_mb_x;
3569     s->first_slice_line=1;
3570     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571         ff_init_block_index(s);
3572         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3574
3575             mb_num++;
3576             ff_update_block_index(s);
3577             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578                 s->first_slice_line=0;
3579
3580             if(s->pict_type==I_TYPE){
3581                 int ac_pred= get_bits1(&s->gb);
3582                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3583                 if(cbpy<0){
3584                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3585                     return -1;
3586                 }
3587
3588                 s->cbp_table[xy]|= cbpy<<2;
3589                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3590             }else{ /* P || S_TYPE */
3591                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3592                     int dir=0,i;
3593                     int ac_pred = get_bits1(&s->gb);
3594                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3595
3596                     if(cbpy<0){
3597                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3598                         return -1;
3599                     }
3600
3601                     if(s->cbp_table[xy] & 8) {
3602                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3603                     }
3604                     s->current_picture.qscale_table[xy]= s->qscale;
3605
3606                     for(i=0; i<6; i++){
3607                         int dc_pred_dir;
3608                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3609                         if(dc < 0){
3610                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3611                             return -1;
3612                         }
3613                         dir<<=1;
3614                         if(dc_pred_dir) dir|=1;
3615                     }
3616                     s->cbp_table[xy]&= 3; //remove dquant
3617                     s->cbp_table[xy]|= cbpy<<2;
3618                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3619                     s->pred_dir_table[xy]= dir;
3620                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621                     s->current_picture.qscale_table[xy]= s->qscale;
3622                     s->cbp_table[xy]= 0;
3623                 }else{
3624                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3625
3626                     if(cbpy<0){
3627                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3628                         return -1;
3629                     }
3630
3631                     if(s->cbp_table[xy] & 8) {
3632                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3633                     }
3634                     s->current_picture.qscale_table[xy]= s->qscale;
3635
3636                     s->cbp_table[xy]&= 3; //remove dquant
3637                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3638                 }
3639             }
3640         }
3641         if(mb_num >= mb_count) return 0;
3642         s->mb_x= 0;
3643     }
3644     return 0;
3645 }
3646
3647 /**
3648  * decodes the first & second partition
3649  * @return <0 if error (and sets error type in the error_status_table)
3650  */
3651 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3652 {
3653     int mb_num;
3654     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3656
3657     mb_num= mpeg4_decode_partition_a(s);
3658     if(mb_num<0){
3659         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3660         return -1;
3661     }
3662
3663     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3666         return -1;
3667     }
3668
3669     s->mb_num_left= mb_num;
3670
3671     if(s->pict_type==I_TYPE){
3672         while(show_bits(&s->gb, 9) == 1)
3673             skip_bits(&s->gb, 9);
3674         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3676             return -1;
3677         }
3678     }else{
3679         while(show_bits(&s->gb, 10) == 1)
3680             skip_bits(&s->gb, 10);
3681         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3683             return -1;
3684         }
3685     }
3686     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3687
3688     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689         if(s->pict_type==P_TYPE)
3690             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3691         return -1;
3692     }else{
3693         if(s->pict_type==P_TYPE)
3694             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3695     }
3696
3697     return 0;
3698 }
3699
3700 /**
3701  * decode partition C of one MB.
3702  * @return <0 if an error occured
3703  */
3704 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3705 {
3706     int cbp, mb_type;
3707     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3708
3709     mb_type= s->current_picture.mb_type[xy];
3710     cbp = s->cbp_table[xy];
3711
3712     if(s->current_picture.qscale_table[xy] != s->qscale){
3713         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3714     }
3715
3716     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3717         int i;
3718         for(i=0; i<4; i++){
3719             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3720             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3721         }
3722         s->mb_intra = IS_INTRA(mb_type);
3723
3724         if (IS_SKIP(mb_type)) {
3725             /* skip mb */
3726             for(i=0;i<6;i++)
3727                 s->block_last_index[i] = -1;
3728             s->mv_dir = MV_DIR_FORWARD;
3729             s->mv_type = MV_TYPE_16X16;
3730             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3731                 s->mcsel=1;
3732                 s->mb_skipped = 0;
3733             }else{
3734                 s->mcsel=0;
3735                 s->mb_skipped = 1;
3736             }
3737         }else if(s->mb_intra){
3738             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3739         }else if(!s->mb_intra){
3740 //            s->mcsel= 0; //FIXME do we need to init that
3741
3742             s->mv_dir = MV_DIR_FORWARD;
3743             if (IS_8X8(mb_type)) {
3744                 s->mv_type = MV_TYPE_8X8;
3745             } else {
3746                 s->mv_type = MV_TYPE_16X16;
3747             }
3748         }
3749     } else { /* I-Frame */
3750         s->mb_intra = 1;
3751         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3752     }
3753
3754     if (!IS_SKIP(mb_type)) {
3755         int i;
3756         s->dsp.clear_blocks(s->block[0]);
3757         /* decode each block */
3758         for (i = 0; i < 6; i++) {
3759             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3760                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3761                 return -1;
3762             }
3763             cbp+=cbp;
3764         }
3765     }
3766
3767     /* per-MB end of slice check */
3768
3769     if(--s->mb_num_left <= 0){
3770 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3771         if(mpeg4_is_resync(s))
3772             return SLICE_END;
3773         else
3774             return SLICE_NOEND;
3775     }else{
3776         if(mpeg4_is_resync(s)){
3777             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3778             if(s->cbp_table[xy+delta])
3779                 return SLICE_END;
3780         }
3781         return SLICE_OK;
3782     }
3783 }
3784
3785 /**
3786  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3787  */
3788 static void preview_obmc(MpegEncContext *s){
3789     GetBitContext gb= s->gb;
3790
3791     int cbpc, i, pred_x, pred_y, mx, my;
3792     int16_t *mot_val;
3793     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3794     const int stride= s->b8_stride*2;
3795
3796     for(i=0; i<4; i++)
3797         s->block_index[i]+= 2;
3798     for(i=4; i<6; i++)
3799         s->block_index[i]+= 1;
3800     s->mb_x++;
3801
3802     assert(s->pict_type == P_TYPE);
3803
3804     do{
3805         if (get_bits1(&s->gb)) {
3806             /* skip mb */
3807             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3808             mot_val[0       ]= mot_val[2       ]=
3809             mot_val[0+stride]= mot_val[2+stride]= 0;
3810             mot_val[1       ]= mot_val[3       ]=
3811             mot_val[1+stride]= mot_val[3+stride]= 0;
3812
3813             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3814             goto end;
3815         }
3816         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3817     }while(cbpc == 20);
3818
3819     if(cbpc & 4){
3820         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3821     }else{
3822         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3823         if (cbpc & 8) {
3824             if(s->modified_quant){
3825                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3826                 else                  skip_bits(&s->gb, 5);
3827             }else
3828                 skip_bits(&s->gb, 2);
3829         }
3830
3831         if ((cbpc & 16) == 0) {
3832                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3833                 /* 16x16 motion prediction */
3834                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3835                 if (s->umvplus)
3836                    mx = h263p_decode_umotion(s, pred_x);
3837                 else
3838                    mx = h263_decode_motion(s, pred_x, 1);
3839
3840                 if (s->umvplus)
3841                    my = h263p_decode_umotion(s, pred_y);
3842                 else
3843                    my = h263_decode_motion(s, pred_y, 1);
3844
3845                 mot_val[0       ]= mot_val[2       ]=
3846                 mot_val[0+stride]= mot_val[2+stride]= mx;
3847                 mot_val[1       ]= mot_val[3       ]=
3848                 mot_val[1+stride]= mot_val[3+stride]= my;
3849         } else {
3850             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3851             for(i=0;i<4;i++) {
3852                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3853                 if (s->umvplus)
3854                   mx = h263p_decode_umotion(s, pred_x);
3855                 else
3856                   mx = h263_decode_motion(s, pred_x, 1);
3857
3858                 if (s->umvplus)
3859                   my = h263p_decode_umotion(s, pred_y);
3860                 else
3861                   my = h263_decode_motion(s, pred_y, 1);
3862                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3863                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3864                 mot_val[0] = mx;
3865                 mot_val[1] = my;
3866             }
3867         }
3868     }
3869 end:
3870
3871     for(i=0; i<4; i++)
3872         s->block_index[i]-= 2;
3873     for(i=4; i<6; i++)
3874         s->block_index[i]-= 1;
3875     s->mb_x--;
3876
3877     s->gb= gb;
3878 }
3879
3880 static void h263_decode_dquant(MpegEncContext *s){
3881     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3882
3883     if(s->modified_quant){
3884         if(get_bits1(&s->gb))
3885             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3886         else
3887             s->qscale= get_bits(&s->gb, 5);
3888     }else
3889         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3890     ff_set_qscale(s, s->qscale);
3891 }
3892
3893 int ff_h263_decode_mb(MpegEncContext *s,
3894                       DCTELEM block[6][64])
3895 {
3896     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3897     int16_t *mot_val;
3898     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3899
3900     assert(!s->h263_pred);
3901
3902     if (s->pict_type == P_TYPE) {
3903         do{
3904             if (get_bits1(&s->gb)) {
3905                 /* skip mb */
3906                 s->mb_intra = 0;
3907                 for(i=0;i<6;i++)
3908                     s->block_last_index[i] = -1;
3909                 s->mv_dir = MV_DIR_FORWARD;
3910                 s->mv_type = MV_TYPE_16X16;
3911                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3912                 s->mv[0][0][0] = 0;
3913                 s->mv[0][0][1] = 0;
3914                 s->mb_skipped = !(s->obmc | s->loop_filter);
3915                 goto end;
3916             }
3917             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3918             //fprintf(stderr, "\tCBPC: %d", cbpc);
3919             if (cbpc < 0){
3920                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3921                 return -1;
3922             }
3923         }while(cbpc == 20);
3924
3925         s->dsp.clear_blocks(s->block[0]);
3926
3927         dquant = cbpc & 8;
3928         s->mb_intra = ((cbpc & 4) != 0);
3929         if (s->mb_intra) goto intra;
3930
3931         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3932
3933         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3934             cbpy ^= 0xF;
3935
3936         cbp = (cbpc & 3) | (cbpy << 2);
3937         if (dquant) {
3938             h263_decode_dquant(s);
3939         }
3940
3941         s->mv_dir = MV_DIR_FORWARD;
3942         if ((cbpc & 16) == 0) {
3943             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3944             /* 16x16 motion prediction */
3945             s->mv_type = MV_TYPE_16X16;
3946             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3947             if (s->umvplus)
3948                mx = h263p_decode_umotion(s, pred_x);
3949             else
3950                mx = h263_decode_motion(s, pred_x, 1);
3951
3952             if (mx >= 0xffff)
3953                 return -1;
3954
3955             if (s->umvplus)
3956                my = h263p_decode_umotion(s, pred_y);
3957             else
3958                my = h263_decode_motion(s, pred_y, 1);
3959
3960             if (my >= 0xffff)
3961                 return -1;
3962             s->mv[0][0][0] = mx;
3963             s->mv[0][0][1] = my;
3964
3965             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3966                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3967         } else {
3968             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3969             s->mv_type = MV_TYPE_8X8;
3970             for(i=0;i<4;i++) {
3971                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3972                 if (s->umvplus)
3973                   mx = h263p_decode_umotion(s, pred_x);
3974                 else
3975                   mx = h263_decode_motion(s, pred_x, 1);
3976                 if (mx >= 0xffff)
3977                     return -1;
3978
3979                 if (s->umvplus)
3980                   my = h263p_decode_umotion(s, pred_y);
3981                 else
3982                   my = h263_decode_motion(s, pred_y, 1);
3983                 if (my >= 0xffff)
3984                     return -1;
3985                 s->mv[0][i][0] = mx;
3986                 s->mv[0][i][1] = my;
3987                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3988                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3989                 mot_val[0] = mx;
3990                 mot_val[1] = my;
3991             }
3992         }
3993
3994         /* decode each block */
3995         for (i = 0; i < 6; i++) {
3996             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3997                 return -1;
3998             cbp+=cbp;
3999         }
4000
4001         if(s->obmc){
4002             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4003                 preview_obmc(s);
4004         }
4005     } else if(s->pict_type==B_TYPE) {
4006         int mb_type;
4007         const int stride= s->b8_stride;
4008         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4009         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4010 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4011
4012         //FIXME ugly
4013         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4014         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4015         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4016         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4017
4018         do{
4019             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4020             if (mb_type < 0){
4021                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4022                 return -1;
4023             }
4024
4025             mb_type= h263_mb_type_b_map[ mb_type ];
4026         }while(!mb_type);
4027
4028         s->mb_intra = IS_INTRA(mb_type);
4029         if(HAS_CBP(mb_type)){
4030             s->dsp.clear_blocks(s->block[0]);
4031             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4032             if(s->mb_intra){
4033                 dquant = IS_QUANT(mb_type);
4034                 goto intra;
4035             }
4036
4037             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4038
4039             if (cbpy < 0){
4040                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4041                 return -1;
4042             }
4043
4044             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4045                 cbpy ^= 0xF;
4046
4047             cbp = (cbpc & 3) | (cbpy << 2);
4048         }else
4049             cbp=0;
4050
4051         assert(!s->mb_intra);
4052
4053         if(IS_QUANT(mb_type)){
4054             h263_decode_dquant(s);
4055         }
4056
4057         if(IS_DIRECT(mb_type)){
4058             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4059             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4060         }else{
4061             s->mv_dir = 0;
4062             s->mv_type= MV_TYPE_16X16;
4063 //FIXME UMV
4064
4065             if(USES_LIST(mb_type, 0)){
4066                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4067                 s->mv_dir = MV_DIR_FORWARD;
4068
4069                 mx = h263_decode_motion(s, mx, 1);
4070                 my = h263_decode_motion(s, my, 1);
4071
4072                 s->mv[0][0][0] = mx;
4073                 s->mv[0][0][1] = my;
4074                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4075                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4076             }
4077
4078             if(USES_LIST(mb_type, 1)){
4079                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4080                 s->mv_dir |= MV_DIR_BACKWARD;
4081
4082                 mx = h263_decode_motion(s, mx, 1);
4083                 my = h263_decode_motion(s, my, 1);
4084
4085                 s->mv[1][0][0] = mx;
4086                 s->mv[1][0][1] = my;
4087                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4088                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4089             }
4090         }
4091
4092         s->current_picture.mb_type[xy]= mb_type;
4093
4094         /* decode each block */
4095         for (i = 0; i < 6; i++) {
4096             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4097                 return -1;
4098             cbp+=cbp;
4099         }
4100     } else { /* I-Frame */
4101         do{
4102             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4103             if (cbpc < 0){
4104                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4105                 return -1;
4106             }
4107         }while(cbpc == 8);
4108
4109         s->dsp.clear_blocks(s->block[0]);
4110
4111         dquant = cbpc & 4;
4112         s->mb_intra = 1;
4113 intra:
4114         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4115         if (s->h263_aic) {
4116             s->ac_pred = get_bits1(&s->gb);
4117             if(s->ac_pred){
4118                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4119
4120                 s->h263_aic_dir = get_bits1(&s->gb);
4121             }
4122         }else
4123             s->ac_pred = 0;
4124
4125         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4126         if(cbpy<0){
4127             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4128             return -1;
4129         }
4130         cbp = (cbpc & 3) | (cbpy << 2);
4131         if (dquant) {
4132             h263_decode_dquant(s);
4133         }
4134
4135         /* decode each block */
4136         for (i = 0; i < 6; i++) {
4137             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4138                 return -1;
4139             cbp+=cbp;
4140         }
4141     }
4142 end:
4143
4144         /* per-MB end of slice check */
4145     {
4146         int v= show_bits(&s->gb, 16);
4147
4148         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4149             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4150         }
4151
4152         if(v==0)
4153             return SLICE_END;
4154     }
4155
4156     return SLICE_OK;
4157 }
4158
4159 int ff_mpeg4_decode_mb(MpegEncContext *s,
4160                       DCTELEM block[6][64])
4161 {
4162     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4163     int16_t *mot_val;
4164     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4165     const int xy= s->mb_x + s->mb_y * s->mb_stride;
4166
4167     assert(s->h263_pred);
4168
4169     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4170         do{
4171             if (get_bits1(&s->gb)) {
4172                 /* skip mb */
4173                 s->mb_intra = 0;
4174                 for(i=0;i<6;i++)
4175                     s->block_last_index[i] = -1;
4176                 s->mv_dir = MV_DIR_FORWARD;
4177                 s->mv_type = MV_TYPE_16X16;
4178                 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4179                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4180                     s->mcsel=1;
4181                     s->mv[0][0][0]= get_amv(s, 0);
4182                     s->mv[0][0][1]= get_amv(s, 1);
4183
4184                     s->mb_skipped = 0;
4185                 }else{
4186                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4187                     s->mcsel=0;
4188                     s->mv[0][0][0] = 0;
4189                     s->mv[0][0][1] = 0;
4190                     s->mb_skipped = 1;
4191                 }
4192                 goto end;
4193             }
4194             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4195             //fprintf(stderr, "\tCBPC: %d", cbpc);
4196             if (cbpc < 0){
4197                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4198                 return -1;
4199             }
4200         }while(cbpc == 20);
4201
4202         s->dsp.clear_blocks(s->block[0]);
4203         dquant = cbpc & 8;
4204         s->mb_intra = ((cbpc & 4) != 0);
4205         if (s->mb_intra) goto intra;
4206
4207         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4208             s->mcsel= get_bits1(&s->gb);
4209         else s->mcsel= 0;
4210         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4211
4212         cbp = (cbpc & 3) | (cbpy << 2);
4213         if (dquant) {
4214             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4215         }
4216         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4217             s->interlaced_dct= get_bits1(&s->gb);
4218
4219         s->mv_dir = MV_DIR_FORWARD;
4220         if ((cbpc & 16) == 0) {
4221             if(s->mcsel){
4222                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4223                 /* 16x16 global motion prediction */
4224                 s->mv_type = MV_TYPE_16X16;
4225                 mx= get_amv(s, 0);
4226                 my= get_amv(s, 1);
4227                 s->mv[0][0][0] = mx;
4228                 s->mv[0][0][1] = my;
4229             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4230                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4231                 /* 16x8 field motion prediction */
4232                 s->mv_type= MV_TYPE_FIELD;
4233
4234                 s->field_select[0][0]= get_bits1(&s->gb);
4235                 s->field_select[0][1]= get_bits1(&s->gb);
4236
4237                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4238
4239                 for(i=0; i<2; i++){
4240                     mx = h263_decode_motion(s, pred_x, s->f_code);
4241                     if (mx >= 0xffff)
4242                         return -1;
4243
4244                     my = h263_decode_motion(s, pred_y/2, s->f_code);
4245                     if (my >= 0xffff)
4246                         return -1;
4247
4248                     s->mv[0][i][0] = mx;
4249                     s->mv[0][i][1] = my;
4250                 }
4251             }else{
4252                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4253                 /* 16x16 motion prediction */
4254                 s->mv_type = MV_TYPE_16X16;
4255                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4256                 mx = h263_decode_motion(s, pred_x, s->f_code);
4257
4258                 if (mx >= 0xffff)
4259                     return -1;
4260
4261                 my = h263_decode_motion(s, pred_y, s->f_code);
4262
4263                 if (my >= 0xffff)
4264                     return -1;
4265                 s->mv[0][0][0] = mx;
4266                 s->mv[0][0][1] = my;
4267             }
4268         } else {
4269             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4270             s->mv_type = MV_TYPE_8X8;
4271             for(i=0;i<4;i++) {
4272                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4273                 mx = h263_decode_motion(s, pred_x, s->f_code);
4274                 if (mx >= 0xffff)
4275                     return -1;
4276
4277                 my = h263_decode_motion(s, pred_y, s->f_code);
4278                 if (my >= 0xffff)
4279                     return -1;
4280                 s->mv[0][i][0] = mx;
4281                 s->mv[0][i][1] = my;
4282                 mot_val[0] = mx;
4283                 mot_val[1] = my;
4284             }
4285         }
4286     } else if(s->pict_type==B_TYPE) {
4287         int modb1; // first bit of modb
4288         int modb2; // second bit of modb
4289         int mb_type;
4290
4291         s->mb_intra = 0; //B-frames never contain intra blocks
4292         s->mcsel=0;      //     ...               true gmc blocks
4293
4294         if(s->mb_x==0){
4295             for(i=0; i<2; i++){
4296                 s->last_mv[i][0][0]=
4297                 s->last_mv[i][0][1]=
4298                 s->last_mv[i][1][0]=
4299                 s->last_mv[i][1][1]= 0;
4300             }
4301         }
4302
4303         /* if we skipped it in the future P Frame than skip it now too */
4304         s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4305
4306         if(s->mb_skipped){
4307                 /* skip mb */
4308             for(i=0;i<6;i++)
4309                 s->block_last_index[i] = -1;
4310
4311             s->mv_dir = MV_DIR_FORWARD;
4312             s->mv_type = MV_TYPE_16X16;
4313             s->mv[0][0][0] = 0;
4314             s->mv[0][0][1] = 0;
4315             s->mv[1][0][0] = 0;
4316             s->mv[1][0][1] = 0;
4317             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4318             goto end;
4319         }
4320
4321         modb1= get_bits1(&s->gb);
4322         if(modb1){
4323             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4324             cbp=0;
4325         }else{
4326             modb2= get_bits1(&s->gb);
4327             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4328             if(mb_type<0){
4329                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4330                 return -1;
4331             }
4332             mb_type= mb_type_b_map[ mb_type ];
4333             if(modb2) cbp= 0;
4334             else{
4335                 s->dsp.clear_blocks(s->block[0]);
4336                 cbp= get_bits(&s->gb, 6);
4337             }
4338
4339             if ((!IS_DIRECT(mb_type)) && cbp) {
4340                 if(get_bits1(&s->gb)){
4341                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4342                 }
4343             }
4344
4345             if(!s->progressive_sequence){
4346                 if(cbp)
4347                     s->interlaced_dct= get_bits1(&s->gb);
4348
4349                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4350                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4351                     mb_type &= ~MB_TYPE_16x16;
4352
4353                     if(USES_LIST(mb_type, 0)){
4354                         s->field_select[0][0]= get_bits1(&s->gb);
4355                         s->field_select[0][1]= get_bits1(&s->gb);
4356                     }
4357                     if(USES_LIST(mb_type, 1)){
4358                         s->field_select[1][0]= get_bits1(&s->gb);
4359                         s->field_select[1][1]= get_bits1(&s->gb);
4360                     }
4361                 }
4362             }
4363
4364             s->mv_dir = 0;
4365             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4366                 s->mv_type= MV_TYPE_16X16;
4367
4368                 if(USES_LIST(mb_type, 0)){
4369                     s->mv_dir = MV_DIR_FORWARD;
4370
4371                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4372                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4373                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4374                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4375                 }
4376
4377                 if(USES_LIST(mb_type, 1)){
4378                     s->mv_dir |= MV_DIR_BACKWARD;
4379
4380                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4381                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4382                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4383                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4384                 }
4385             }else if(!IS_DIRECT(mb_type)){
4386                 s->mv_type= MV_TYPE_FIELD;
4387
4388                 if(USES_LIST(mb_type, 0)){
4389                     s->mv_dir = MV_DIR_FORWARD;
4390
4391                     for(i=0; i<2; i++){
4392                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4393                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4394                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4395                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4396                     }
4397                 }
4398
4399                 if(USES_LIST(mb_type, 1)){
4400                     s->mv_dir |= MV_DIR_BACKWARD;
4401
4402                     for(i=0; i<2; i++){
4403                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4404                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4405                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4406                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4407                     }
4408                 }
4409             }
4410         }
4411
4412         if(IS_DIRECT(mb_type)){
4413             if(IS_SKIP(mb_type))
4414                 mx=my=0;
4415             else{
4416                 mx = h263_decode_motion(s, 0, 1);
4417                 my = h263_decode_motion(s, 0, 1);
4418             }
4419
4420             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4421             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4422         }
4423         s->current_picture.mb_type[xy]= mb_type;
4424     } else { /* I-Frame */
4425         do{
4426             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4427             if (cbpc < 0){
4428                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4429                 return -1;
4430             }
4431         }while(cbpc == 8);
4432
4433         dquant = cbpc & 4;
4434         s->mb_intra = 1;
4435 intra:
4436         s->ac_pred = get_bits1(&s->gb);
4437         if(s->ac_pred)
4438             s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4439         else
4440             s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4441
4442         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4443         if(cbpy<0){
4444             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4445             return -1;
4446         }
4447         cbp = (cbpc & 3) | (cbpy << 2);
4448         if (dquant) {
4449             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4450         }
4451
4452         if(!s->progressive_sequence)
4453             s->interlaced_dct= get_bits1(&s->gb);
4454
4455         s->dsp.clear_blocks(s->block[0]);
4456         /* decode each block */
4457         for (i = 0; i < 6; i++) {
4458             if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4459                 return -1;
4460             cbp+=cbp;
4461         }
4462         goto end;
4463     }
4464
4465     /* decode each block */
4466     for (i = 0; i < 6; i++) {
4467         if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4468             return -1;
4469         cbp+=cbp;
4470     }
4471 end:
4472
4473         /* per-MB end of slice check */
4474     if(s->codec_id==CODEC_ID_MPEG4){
4475         if(mpeg4_is_resync(s)){
4476             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4477             if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4478                 return SLICE_OK;
4479             return SLICE_END;
4480         }
4481     }
4482
4483     return SLICE_OK;
4484 }
4485
4486 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4487 {
4488     int code, val, sign, shift, l;
4489     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4490
4491     if (code == 0)
4492         return pred;
4493     if (code < 0)
4494         return 0xffff;
4495
4496     sign = get_bits1(&s->gb);
4497     shift = f_code - 1;
4498     val = code;
4499     if (shift) {
4500         val = (val - 1) << shift;
4501         val |= get_bits(&s->gb, shift);
4502         val++;
4503     }
4504     if (sign)
4505         val = -val;
4506     val += pred;
4507
4508     /* modulo decoding */
4509     if (!s->h263_long_vectors) {
4510         l = INT_BIT - 5 - f_code;
4511         val = (val<<l)>>l;
4512     } else {
4513         /* horrible h263 long vector mode */
4514         if (pred < -31 && val < -63)
4515             val += 64;
4516         if (pred > 32 && val > 63)
4517             val -= 64;
4518
4519     }
4520     return val;
4521 }
4522
4523 /* Decodes RVLC of H.263+ UMV */
4524 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4525 {
4526    int code = 0, sign;
4527
4528    if (get_bits1(&s->gb)) /* Motion difference = 0 */
4529       return pred;
4530
4531    code = 2 + get_bits1(&s->gb);
4532
4533    while (get_bits1(&s->gb))
4534    {
4535       code <<= 1;
4536       code += get_bits1(&s->gb);
4537    }
4538    sign = code & 1;
4539    code >>= 1;
4540
4541    code = (sign) ? (pred - code) : (pred + code);
4542 #ifdef DEBUG
4543    av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4544 #endif
4545    return code;
4546
4547 }
4548
4549 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4550                              int n, int coded)
4551 {
4552     int code, level, i, j, last, run;
4553     RLTable *rl = &rl_inter;
4554     const uint8_t *scan_table;
4555     GetBitContext gb= s->gb;
4556
4557     scan_table = s->intra_scantable.permutated;
4558     if (s->h263_aic && s->mb_intra) {
4559         rl = &rl_intra_aic;
4560         i = 0;
4561         if (s->ac_pred) {
4562             if (s->h263_aic_dir)
4563                 scan_table = s->intra_v_scantable.permutated; /* left */
4564             else
4565                 scan_table = s->intra_h_scantable.permutated; /* top */
4566         }
4567     } else if (s->mb_intra) {
4568         /* DC coef */
4569         if(s->codec_id == CODEC_ID_RV10){
4570 #ifdef CONFIG_RV10_DECODER
4571           if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4572             int component, diff;
4573             component = (n <= 3 ? 0 : n - 4 + 1);
4574             level = s->last_dc[component];
4575             if (s->rv10_first_dc_coded[component]) {
4576                 diff = rv_decode_dc(s, n);
4577                 if (diff == 0xffff)
4578                     return -1;
4579                 level += diff;
4580                 level = level & 0xff; /* handle wrap round */
4581                 s->last_dc[component] = level;
4582             } else {
4583                 s->rv10_first_dc_coded[component] = 1;
4584             }
4585           } else {
4586                 level = get_bits(&s->gb, 8);
4587                 if (level == 255)
4588                     level = 128;
4589           }
4590 #endif
4591         }else{
4592             level = get_bits(&s->gb, 8);
4593             if((level&0x7F) == 0){
4594                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4595                 if(s->error_resilience >= FF_ER_COMPLIANT)
4596                     return -1;
4597             }
4598             if (level == 255)
4599                 level = 128;
4600         }
4601         block[0] = level;
4602         i = 1;
4603     } else {
4604         i = 0;
4605     }
4606     if (!coded) {
4607         if (s->mb_intra && s->h263_aic)
4608             goto not_coded;
4609         s->block_last_index[n] = i - 1;
4610         return 0;
4611     }
4612 retry:
4613     for(;;) {
4614         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4615         if (code < 0){
4616             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4617             return -1;
4618         }
4619         if (code == rl->n) {
4620             /* escape */
4621             if (s->h263_flv > 1) {
4622                 int is11 = get_bits1(&s->gb);
4623                 last = get_bits1(&s->gb);
4624                 run = get_bits(&s->gb, 6);
4625                 if(is11){
4626                     level = get_sbits(&s->gb, 11);
4627                 } else {
4628                     level = get_sbits(&s->gb, 7);
4629                 }
4630             } else {
4631                 last = get_bits1(&s->gb);
4632                 run = get_bits(&s->gb, 6);
4633                 level = (int8_t)get_bits(&s->gb, 8);
4634                 if(level == -128){
4635                     if (s->codec_id == CODEC_ID_RV10) {
4636                         /* XXX: should patch encoder too */
4637                         level = get_sbits(&s->gb, 12);
4638                     }else{
4639                         level = get_bits(&s->gb, 5);
4640                         level |= get_sbits(&s->gb, 6)<<5;
4641                     }
4642                 }
4643             }
4644         } else {
4645             run = rl->table_run[code];
4646             level = rl->table_level[code];
4647             last = code >= rl->last;
4648             if (get_bits1(&s->gb))
4649                 level = -level;
4650         }
4651         i += run;
4652         if (i >= 64){
4653             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4654                 //looks like a hack but no, it's the way its supposed to work ...
4655                 rl = &rl_intra_aic;
4656                 i = 0;
4657                 s->gb= gb;
4658                 memset(block, 0, sizeof(DCTELEM)*64);
4659                 goto retry;
4660             }
4661             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4662             return -1;
4663         }
4664         j = scan_table[i];
4665         block[j] = level;
4666         if (last)
4667             break;
4668         i++;
4669     }
4670 not_coded:
4671     if (s->mb_intra && s->h263_aic) {
4672         h263_pred_acdc(s, block, n);
4673         i = 63;
4674     }
4675     s->block_last_index[n] = i;
4676     return 0;
4677 }
4678
4679 /**
4680  * decodes the dc value.
4681  * @param n block index (0-3 are luma, 4-5 are chroma)
4682  * @param dir_ptr the prediction direction will be stored here
4683  * @return the quantized dc
4684  */
4685 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4686 {
4687     int level, code;
4688
4689     if (n < 4)
4690         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4691     else
4692         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4693     if (code < 0 || code > 9 /* && s->nbit<9 */){
4694         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4695         return -1;
4696     }
4697     if (code == 0) {
4698         level = 0;
4699     } else {
4700         if(IS_3IV1){
4701             if(code==1)
4702                 level= 2*get_bits1(&s->gb)-1;
4703             else{
4704                 if(get_bits1(&s->gb))
4705                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
4706                 else
4707                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4708             }
4709         }else{
4710             level = get_xbits(&s->gb, code);
4711         }
4712
4713         if (code > 8){
4714             if(get_bits1(&s->gb)==0){ /* marker */
4715                 if(s->error_resilience>=2){
4716                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4717                     return -1;
4718                 }
4719             }
4720         }
4721     }
4722
4723     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4724 }
4725
4726 /**
4727  * decodes a block.
4728  * @return <0 if an error occured
4729  */
4730 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4731                               int n, int coded, int intra, int rvlc)
4732 {
4733     int level, i, last, run;
4734     int dc_pred_dir;
4735     RLTable * rl;
4736     RL_VLC_ELEM * rl_vlc;
4737     const uint8_t * scan_table;
4738     int qmul, qadd;
4739
4740     //Note intra & rvlc should be optimized away if this is inlined
4741
4742     if(intra) {
4743       if(s->qscale < s->intra_dc_threshold){
4744         /* DC coef */
4745         if(s->partitioned_frame){
4746             level = s->dc_val[0][ s->block_index[n] ];
4747             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4748             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4749             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4750         }else{
4751             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4752             if (level < 0)
4753                 return -1;
4754         }
4755         block[0] = level;
4756         i = 0;
4757       }else{
4758             i = -1;
4759       }
4760         if (!coded)
4761             goto not_coded;
4762
4763         if(rvlc){
4764             rl = &rvlc_rl_intra;
4765             rl_vlc = rvlc_rl_intra.rl_vlc[0];
4766         }else{
4767             rl = &rl_intra;
4768             rl_vlc = rl_intra.rl_vlc[0];
4769         }
4770         if (s->ac_pred) {
4771             if (dc_pred_dir == 0)
4772                 scan_table = s->intra_v_scantable.permutated; /* left */
4773             else
4774                 scan_table = s->intra_h_scantable.permutated; /* top */
4775         } else {
4776             scan_table = s->intra_scantable.permutated;
4777         }
4778         qmul=1;
4779         qadd=0;
4780     } else {
4781         i = -1;
4782         if (!coded) {
4783             s->block_last_index[n] = i;
4784             return 0;
4785         }
4786         if(rvlc) rl = &rvlc_rl_inter;
4787         else     rl = &rl_inter;
4788
4789         scan_table = s->intra_scantable.permutated;
4790
4791         if(s->mpeg_quant){
4792             qmul=1;
4793             qadd=0;
4794             if(rvlc){
4795                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4796             }else{
4797                 rl_vlc = rl_inter.rl_vlc[0];
4798             }
4799         }else{
4800             qmul = s->qscale << 1;
4801             qadd = (s->qscale - 1) | 1;
4802             if(rvlc){
4803                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4804             }else{
4805                 rl_vlc = rl_inter.rl_vlc[s->qscale];
4806             }
4807         }
4808     }
4809   {
4810     OPEN_READER(re, &s->gb);
4811     for(;;) {
4812         UPDATE_CACHE(re, &s->gb);
4813         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4814         if (level==0) {
4815           /* escape */
4816           if(rvlc){
4817                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4818                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4819                     return -1;
4820                 }; SKIP_CACHE(re, &s->gb, 1);
4821
4822                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4823                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4824                 SKIP_COUNTER(re, &s->gb, 1+1+6);
4825                 UPDATE_CACHE(re, &s->gb);
4826
4827                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4828                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4829                     return -1;
4830                 }; SKIP_CACHE(re, &s->gb, 1);
4831
4832                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4833
4834                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4835                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4836                     return -1;
4837                 }; SKIP_CACHE(re, &s->gb, 5);
4838
4839                 level=  level * qmul + qadd;
4840                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4841                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4842
4843                 i+= run + 1;
4844                 if(last) i+=192;
4845           }else{
4846             int cache;
4847             cache= GET_CACHE(re, &s->gb);
4848
4849             if(IS_3IV1)
4850                 cache ^= 0xC0000000;
4851
4852             if (cache&0x80000000) {
4853                 if (cache&0x40000000) {
4854                     /* third escape */
4855                     SKIP_CACHE(re, &s->gb, 2);
4856                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4857                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4858                     SKIP_COUNTER(re, &s->gb, 2+1+6);
4859                     UPDATE_CACHE(re, &s->gb);
4860
4861                     if(IS_3IV1){
4862                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4863                     }else{
4864                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4865                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4866                             return -1;
4867                         }; SKIP_CACHE(re, &s->gb, 1);
4868
4869                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4870
4871                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4872                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4873                             return -1;
4874                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
4875
4876                         SKIP_COUNTER(re, &s->gb, 1+12+1);
4877                     }
4878
4879 #if 0
4880                     if(s->error_resilience >= FF_ER_COMPLIANT){
4881                         const int abs_level= ABS(level);
4882                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4883                             const int run1= run - rl->max_run[last][abs_level] - 1;
4884                             if(abs_level <= rl->max_level[last][run]){
4885                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4886                                 return -1;
4887                             }
4888                             if(s->error_resilience > FF_ER_COMPLIANT){
4889                                 if(abs_level <= rl->max_level[last][run]*2){
4890                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4891                                     return -1;
4892                                 }
4893                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4894                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4895                                     return -1;
4896                                 }
4897                             }
4898                         }
4899                     }
4900 #endif
4901                     if (level>0) level= level * qmul + qadd;
4902                     else         level= level * qmul - qadd;
4903
4904                     if((unsigned)(level + 2048) > 4095){
4905                         if(s->error_resilience > FF_ER_COMPLIANT){
4906                             if(level > 2560 || level<-2560){
4907                                 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4908                                 return -1;
4909                             }
4910                         }
4911                         level= level<0 ? -2048 : 2047;
4912                     }
4913
4914                     i+= run + 1;
4915                     if(last) i+=192;
4916                 } else {
4917                     /* second escape */
4918 #if MIN_CACHE_BITS < 20
4919                     LAST_SKIP_BITS(re, &s->gb, 2);
4920                     UPDATE_CACHE(re, &s->gb);
4921 #else
4922                     SKIP_BITS(re, &s->gb, 2);
4923 #endif
4924                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4925                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4926                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4927                     LAST_SKIP_BITS(re, &s->gb, 1);
4928                 }
4929             } else {
4930                 /* first escape */
4931 #if MIN_CACHE_BITS < 19
4932                 LAST_SKIP_BITS(re, &s->gb, 1);
4933                 UPDATE_CACHE(re, &s->gb);
4934 #else
4935                 SKIP_BITS(re, &s->gb, 1);
4936 #endif
4937                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4938                 i+= run;
4939                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4940                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4941                 LAST_SKIP_BITS(re, &s->gb, 1);
4942             }
4943           }
4944         } else {
4945             i+= run;
4946             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4947             LAST_SKIP_BITS(re, &s->gb, 1);
4948         }
4949         if (i > 62){
4950             i-= 192;
4951             if(i&(~63)){
4952                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4953                 return -1;
4954             }
4955
4956             block[scan_table[i]] = level;
4957             break;
4958         }
4959
4960         block[scan_table[i]] = level;
4961     }
4962     CLOSE_READER(re, &s->gb);
4963   }
4964  not_coded:
4965     if (intra) {
4966         if(s->qscale >= s->intra_dc_threshold){
4967             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
4968
4969             if(i == -1) i=0;
4970         }
4971
4972         mpeg4_pred_ac(s, block, n, dc_pred_dir);
4973         if (s->ac_pred) {
4974             i = 63; /* XXX: not optimal */
4975         }
4976     }
4977     s->block_last_index[n] = i;
4978     return 0;
4979 }
4980
4981 /* most is hardcoded. should extend to handle all h263 streams */
4982 int h263_decode_picture_header(MpegEncContext *s)
4983 {
4984     int format, width, height, i;
4985     uint32_t startcode;
4986
4987     align_get_bits(&s->gb);
4988
4989     startcode= get_bits(&s->gb, 22-8);
4990
4991     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4992         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4993
4994         if(startcode == 0x20)
4995             break;
4996     }
4997
4998     if (startcode != 0x20) {
4999         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5000         return -1;
5001     }
5002     /* temporal reference */
5003     i = get_bits(&s->gb, 8); /* picture timestamp */
5004     if( (s->picture_number&~0xFF)+i < s->picture_number)
5005         i+= 256;
5006     s->current_picture_ptr->pts=
5007     s->picture_number= (s->picture_number&~0xFF) + i;
5008
5009     /* PTYPE starts here */
5010     if (get_bits1(&s->gb) != 1) {
5011         /* marker */
5012         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5013         return -1;
5014     }
5015     if (get_bits1(&s->gb) != 0) {
5016         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5017         return -1;      /* h263 id */
5018     }
5019     skip_bits1(&s->gb);         /* split screen off */
5020     skip_bits1(&s->gb);         /* camera  off */
5021     skip_bits1(&s->gb);         /* freeze picture release off */
5022
5023     format = get_bits(&s->gb, 3);
5024     /*
5025         0    forbidden
5026         1    sub-QCIF
5027         10   QCIF
5028         7       extended PTYPE (PLUSPTYPE)
5029     */
5030
5031     if (format != 7 && format != 6) {
5032         s->h263_plus = 0;
5033         /* H.263v1 */
5034         width = h263_format[format][0];
5035         height = h263_format[format][1];
5036         if (!width)
5037             return -1;
5038
5039         s->pict_type = I_TYPE + get_bits1(&s->gb);
5040
5041         s->h263_long_vectors = get_bits1(&s->gb);
5042
5043         if (get_bits1(&s->gb) != 0) {
5044             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5045             return -1; /* SAC: off */
5046         }
5047         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5048         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5049
5050         if (get_bits1(&s->gb) != 0) {
5051             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5052             return -1; /* not PB frame */
5053         }
5054         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5055         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5056
5057         s->width = width;
5058         s->height = height;
5059         s->avctx->sample_aspect_ratio= (AVRational){12,11};
5060         s->avctx->time_base= (AVRational){1001, 30000};
5061     } else {
5062         int ufep;
5063
5064         /* H.263v2 */
5065         s->h263_plus = 1;
5066         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5067
5068         /* ufep other than 0 and 1 are reserved */
5069         if (ufep == 1) {
5070             /* OPPTYPE */
5071             format = get_bits(&s->gb, 3);
5072             dprintf("ufep=1, format: %d\n", format);
5073             s->custom_pcf= get_bits1(&s->gb);
5074             s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5075             if (get_bits1(&s->gb) != 0) {
5076                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5077             }
5078             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5079             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5080             s->loop_filter= get_bits1(&s->gb);
5081             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5082
5083             s->h263_slice_structured= get_bits1(&s->gb);
5084             if (get_bits1(&s->gb) != 0) {
5085                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5086             }
5087             if (get_bits1(&s->gb) != 0) {
5088                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5089             }
5090             s->alt_inter_vlc= get_bits1(&s->gb);
5091             s->modified_quant= get_bits1(&s->gb);
5092             if(s->modified_quant)
5093                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5094
5095             skip_bits(&s->gb, 1); /* Prevent start code emulation */
5096
5097             skip_bits(&s->gb, 3); /* Reserved */
5098         } else if (ufep != 0) {
5099             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5100             return -1;
5101         }
5102
5103         /* MPPTYPE */
5104         s->pict_type = get_bits(&s->gb, 3);
5105         switch(s->pict_type){
5106         case 0: s->pict_type= I_TYPE;break;
5107         case 1: s->pict_type= P_TYPE;break;
5108         case 3: s->pict_type= B_TYPE;break;
5109         case 7: s->pict_type= I_TYPE;break; //ZYGO
5110         default:
5111             return -1;
5112         }
5113         skip_bits(&s->gb, 2);
5114         s->no_rounding = get_bits1(&s->gb);
5115         skip_bits(&s->gb, 4);
5116
5117         /* Get the picture dimensions */
5118         if (ufep) {
5119             if (format == 6) {
5120                 /* Custom Picture Format (CPFMT) */
5121                 s->aspect_ratio_info = get_bits(&s->gb, 4);
5122                 dprintf("aspect: %d\n", s->aspect_ratio_info);
5123                 /* aspect ratios:
5124                 0 - forbidden
5125                 1 - 1:1
5126                 2 - 12:11 (CIF 4:3)
5127                 3 - 10:11 (525-type 4:3)
5128                 4 - 16:11 (CIF 16:9)
5129                 5 - 40:33 (525-type 16:9)
5130                 6-14 - reserved
5131                 */
5132                 width = (get_bits(&s->gb, 9) + 1) * 4;
5133                 skip_bits1(&s->gb);
5134                 height = get_bits(&s->gb, 9) * 4;
5135                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5136                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5137                     /* aspected dimensions */
5138                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5139                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5140                 }else{
5141                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5142                 }
5143             } else {
5144                 width = h263_format[format][0];
5145                 height = h263_format[format][1];
5146                 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5147             }
5148             if ((width == 0) || (height == 0))
5149                 return -1;
5150             s->width = width;
5151             s->height = height;
5152
5153             if(s->custom_pcf){
5154                 int gcd;
5155                 s->avctx->time_base.den= 1800000;
5156                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5157                 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5158                 if(s->avctx->time_base.num == 0){
5159                     av_log(s, AV_LOG_ERROR, "zero framerate\n");
5160                     return -1;
5161                 }
5162                 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5163                 s->avctx->time_base.den /= gcd;
5164                 s->avctx->time_base.num /= gcd;
5165 //                av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5166             }else{
5167                 s->avctx->time_base= (AVRational){1001, 30000};
5168             }
5169         }
5170
5171         if(s->custom_pcf){
5172             skip_bits(&s->gb, 2); //extended Temporal reference
5173         }
5174
5175         if (ufep) {
5176             if (s->umvplus) {
5177                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5178                     skip_bits1(&s->gb);
5179             }
5180             if(s->h263_slice_structured){
5181                 if (get_bits1(&s->gb) != 0) {
5182                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5183                 }
5184                 if (get_bits1(&s->gb) != 0) {
5185                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5186                 }
5187             }
5188         }
5189
5190         s->qscale = get_bits(&s->gb, 5);
5191     }
5192
5193     s->mb_width = (s->width  + 15) / 16;
5194     s->mb_height = (s->height  + 15) / 16;
5195     s->mb_num = s->mb_width * s->mb_height;
5196
5197     /* PEI */
5198     while (get_bits1(&s->gb) != 0) {
5199         skip_bits(&s->gb, 8);
5200     }
5201
5202     if(s->h263_slice_structured){
5203         if (get_bits1(&s->gb) != 1) {
5204             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5205             return -1;
5206         }
5207
5208         ff_h263_decode_mba(s);
5209
5210         if (get_bits1(&s->gb) != 1) {
5211             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5212             return -1;
5213         }
5214     }
5215     s->f_code = 1;
5216
5217     if(s->h263_aic){
5218          s->y_dc_scale_table=
5219          s->c_dc_scale_table= ff_aic_dc_scale_table;
5220     }else{
5221         s->y_dc_scale_table=
5222         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5223     }
5224
5225      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5226          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",
5227          s->qscale, av_get_pict_type_char(s->pict_type),
5228          s->gb.size_in_bits, 1-s->no_rounding,
5229          s->obmc ? " AP" : "",
5230          s->umvplus ? " UMV" : "",
5231          s->h263_long_vectors ? " LONG" : "",
5232          s->h263_plus ? " +" : "",
5233          s->h263_aic ? " AIC" : "",
5234          s->alt_inter_vlc ? " AIV" : "",
5235          s->modified_quant ? " MQ" : "",
5236          s->loop_filter ? " LOOP" : "",
5237          s->h263_slice_structured ? " SS" : "",
5238          s->avctx->time_base.den, s->avctx->time_base.num
5239          );
5240      }
5241 #if 1
5242     if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5243         int i,j;
5244         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5245         av_log(s->avctx, AV_LOG_DEBUG, "\n");
5246         for(i=0; i<13; i++){
5247             for(j=0; j<3; j++){
5248                 int v= get_bits(&s->gb, 8);
5249                 v |= get_sbits(&s->gb, 8)<<8;
5250                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5251             }
5252             av_log(s->avctx, AV_LOG_DEBUG, "\n");
5253         }
5254         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5255     }
5256 #endif
5257
5258     return 0;
5259 }
5260
5261 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5262 {
5263     int i;
5264     int a= 2<<s->sprite_warping_accuracy;
5265     int rho= 3-s->sprite_warping_accuracy;
5266     int r=16/a;
5267     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5268     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5269     int sprite_ref[4][2];
5270     int virtual_ref[2][2];
5271     int w2, h2, w3, h3;
5272     int alpha=0, beta=0;
5273     int w= s->width;
5274     int h= s->height;
5275     int min_ab;
5276
5277     for(i=0; i<s->num_sprite_warping_points; i++){
5278         int length;
5279         int x=0, y=0;
5280
5281         length= get_vlc(gb, &sprite_trajectory);
5282         if(length){
5283             x= get_xbits(gb, length);
5284         }
5285         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5286
5287         length= get_vlc(gb, &sprite_trajectory);
5288         if(length){
5289             y=get_xbits(gb, length);
5290         }
5291         skip_bits1(gb); /* marker bit */
5292 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5293         d[i][0]= x;
5294         d[i][1]= y;
5295     }
5296
5297     while((1<<alpha)<w) alpha++;
5298     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5299     w2= 1<<alpha;
5300     h2= 1<<beta;
5301
5302 // Note, the 4th point isn't used for GMC
5303     if(s->divx_version==500 && s->divx_build==413){
5304         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5305         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5306         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5307         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5308         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5309         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5310     } else {
5311         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5312         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5313         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5314         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5315         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5316         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5317     }
5318 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5319     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5320
5321 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5322 // perhaps it should be reordered to be more readable ...
5323 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5324 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5325     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5326         + 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);
5327     virtual_ref[0][1]= 16*vop_ref[0][1]
5328         + 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);
5329     virtual_ref[1][0]= 16*vop_ref[0][0]
5330         + 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);
5331     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5332         + 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);
5333
5334     switch(s->num_sprite_warping_points)
5335     {
5336         case 0:
5337             s->sprite_offset[0][0]= 0;
5338             s->sprite_offset[0][1]= 0;
5339             s->sprite_offset[1][0]= 0;
5340             s->sprite_offset[1][1]= 0;
5341             s->sprite_delta[0][0]= a;
5342             s->sprite_delta[0][1]= 0;
5343             s->sprite_delta[1][0]= 0;
5344             s->sprite_delta[1][1]= a;
5345             s->sprite_shift[0]= 0;
5346             s->sprite_shift[1]= 0;
5347             break;
5348         case 1: //GMC only
5349             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5350             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5351             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5352             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5353             s->sprite_delta[0][0]= a;
5354             s->sprite_delta[0][1]= 0;
5355             s->sprite_delta[1][0]= 0;
5356             s->sprite_delta[1][1]= a;
5357             s->sprite_shift[0]= 0;
5358             s->sprite_shift[1]= 0;
5359             break;
5360         case 2:
5361             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5362                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5363                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5364                                                   + (1<<(alpha+rho-1));
5365             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5366                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5367                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5368                                                   + (1<<(alpha+rho-1));
5369             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5370                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5371                                      +2*w2*r*sprite_ref[0][0]
5372                                      - 16*w2
5373                                      + (1<<(alpha+rho+1)));
5374             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5375                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5376                                      +2*w2*r*sprite_ref[0][1]
5377                                      - 16*w2
5378                                      + (1<<(alpha+rho+1)));
5379             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5380             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5381             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5382             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5383
5384             s->sprite_shift[0]= alpha+rho;
5385             s->sprite_shift[1]= alpha+rho+2;
5386             break;
5387         case 3:
5388             min_ab= FFMIN(alpha, beta);
5389             w3= w2>>min_ab;
5390             h3= h2>>min_ab;
5391             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5392                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5393                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5394                                    + (1<<(alpha+beta+rho-min_ab-1));
5395             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5396                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5397                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5398                                    + (1<<(alpha+beta+rho-min_ab-1));
5399             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5400                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5401                                    + 2*w2*h3*r*sprite_ref[0][0]
5402                                    - 16*w2*h3
5403                                    + (1<<(alpha+beta+rho-min_ab+1));
5404             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5405                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5406                                    + 2*w2*h3*r*sprite_ref[0][1]
5407                                    - 16*w2*h3
5408                                    + (1<<(alpha+beta+rho-min_ab+1));
5409             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5410             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5411             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5412             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5413
5414             s->sprite_shift[0]= alpha + beta + rho - min_ab;
5415             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5416             break;
5417     }
5418     /* try to simplify the situation */
5419     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5420        && s->sprite_delta[0][1] == 0
5421        && s->sprite_delta[1][0] == 0
5422        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5423     {
5424         s->sprite_offset[0][0]>>=s->sprite_shift[0];
5425         s->sprite_offset[0][1]>>=s->sprite_shift[0];
5426         s->sprite_offset[1][0]>>=s->sprite_shift[1];
5427         s->sprite_offset[1][1]>>=s->sprite_shift[1];
5428         s->sprite_delta[0][0]= a;
5429         s->sprite_delta[0][1]= 0;
5430         s->sprite_delta[1][0]= 0;
5431         s->sprite_delta[1][1]= a;
5432         s->sprite_shift[0]= 0;
5433         s->sprite_shift[1]= 0;
5434         s->real_sprite_warping_points=1;
5435     }
5436     else{
5437         int shift_y= 16 - s->sprite_shift[0];
5438         int shift_c= 16 - s->sprite_shift[1];
5439 //printf("shifts %d %d\n", shift_y, shift_c);
5440         for(i=0; i<2; i++){
5441             s->sprite_offset[0][i]<<= shift_y;
5442             s->sprite_offset[1][i]<<= shift_c;
5443             s->sprite_delta[0][i]<<= shift_y;
5444             s->sprite_delta[1][i]<<= shift_y;
5445             s->sprite_shift[i]= 16;
5446         }
5447         s->real_sprite_warping_points= s->num_sprite_warping_points;
5448     }
5449 #if 0
5450 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5451     vop_ref[0][0], vop_ref[0][1],
5452     vop_ref[1][0], vop_ref[1][1],
5453     vop_ref[2][0], vop_ref[2][1],
5454     sprite_ref[0][0], sprite_ref[0][1],
5455     sprite_ref[1][0], sprite_ref[1][1],
5456     sprite_ref[2][0], sprite_ref[2][1],
5457     virtual_ref[0][0], virtual_ref[0][1],
5458     virtual_ref[1][0], virtual_ref[1][1]
5459     );
5460
5461 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5462     s->sprite_offset[0][0], s->sprite_offset[0][1],
5463     s->sprite_delta[0][0], s->sprite_delta[0][1],
5464     s->sprite_delta[1][0], s->sprite_delta[1][1],
5465     s->sprite_shift[0]
5466     );
5467 #endif
5468 }
5469
5470 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5471     int hours, minutes, seconds;
5472
5473     hours= get_bits(gb, 5);
5474     minutes= get_bits(gb, 6);
5475     skip_bits1(gb);
5476     seconds= get_bits(gb, 6);
5477
5478     s->time_base= seconds + 60*(minutes + 60*hours);
5479
5480     skip_bits1(gb);
5481     skip_bits1(gb);
5482
5483     return 0;
5484 }
5485
5486 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5487     int width, height, vo_ver_id;
5488
5489     /* vol header */
5490     skip_bits(gb, 1); /* random access */
5491     s->vo_type= get_bits(gb, 8);
5492     if (get_bits1(gb) != 0) { /* is_ol_id */
5493         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5494         skip_bits(gb, 3); /* vo_priority */
5495     } else {
5496         vo_ver_id = 1;
5497     }
5498 //printf("vo type:%d\n",s->vo_type);
5499     s->aspect_ratio_info= get_bits(gb, 4);
5500     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5501         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5502         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5503     }else{
5504         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5505     }
5506
5507     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5508         int chroma_format= get_bits(gb, 2);
5509         if(chroma_format!=1){
5510             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5511         }
5512         s->low_delay= get_bits1(gb);
5513         if(get_bits1(gb)){ /* vbv parameters */
5514             get_bits(gb, 15);   /* first_half_bitrate */
5515             skip_bits1(gb);     /* marker */
5516             get_bits(gb, 15);   /* latter_half_bitrate */
5517             skip_bits1(gb);     /* marker */
5518             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
5519             skip_bits1(gb);     /* marker */
5520             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
5521             get_bits(gb, 11);   /* first_half_vbv_occupancy */
5522             skip_bits1(gb);     /* marker */
5523             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
5524             skip_bits1(gb);     /* marker */
5525         }
5526     }else{
5527         // set low delay flag only once the smartest? low delay detection won't be overriden
5528         if(s->picture_number==0)
5529             s->low_delay=0;
5530     }
5531
5532     s->shape = get_bits(gb, 2); /* vol shape */
5533     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5534     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5535         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5536         skip_bits(gb, 4);  //video_object_layer_shape_extension
5537     }
5538
5539     check_marker(gb, "before time_increment_resolution");
5540
5541     s->avctx->time_base.den = get_bits(gb, 16);
5542     if(!s->avctx->time_base.den){
5543         av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5544         return -1;
5545     }
5546
5547     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5548     if (s->time_increment_bits < 1)
5549         s->time_increment_bits = 1;
5550
5551     check_marker(gb, "before fixed_vop_rate");
5552
5553     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
5554         s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5555     }else
5556         s->avctx->time_base.num = 1;
5557
5558     s->t_frame=0;
5559
5560     if (s->shape != BIN_ONLY_SHAPE) {
5561         if (s->shape == RECT_SHAPE) {
5562             skip_bits1(gb);   /* marker */
5563             width = get_bits(gb, 13);
5564             skip_bits1(gb);   /* marker */
5565             height = get_bits(gb, 13);
5566             skip_bits1(gb);   /* marker */
5567             if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5568                 s->width = width;
5569                 s->height = height;
5570 //                printf("width/height: %d %d\n", width, height);
5571             }
5572         }
5573
5574         s->progressive_sequence=
5575         s->progressive_frame= get_bits1(gb)^1;
5576         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5577             av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
5578         if (vo_ver_id == 1) {
5579             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5580         } else {
5581             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5582         }
5583         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5584         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5585             if(s->vol_sprite_usage==STATIC_SPRITE){
5586                 s->sprite_width = get_bits(gb, 13);
5587                 skip_bits1(gb); /* marker */
5588                 s->sprite_height= get_bits(gb, 13);
5589                 skip_bits1(gb); /* marker */
5590                 s->sprite_left  = get_bits(gb, 13);
5591                 skip_bits1(gb); /* marker */
5592                 s->sprite_top   = get_bits(gb, 13);
5593                 skip_bits1(gb); /* marker */
5594             }
5595             s->num_sprite_warping_points= get_bits(gb, 6);
5596             s->sprite_warping_accuracy = get_bits(gb, 2);
5597             s->sprite_brightness_change= get_bits1(gb);
5598             if(s->vol_sprite_usage==STATIC_SPRITE)
5599                 s->low_latency_sprite= get_bits1(gb);
5600         }
5601         // FIXME sadct disable bit if verid!=1 && shape not rect
5602
5603         if (get_bits1(gb) == 1) {   /* not_8_bit */
5604             s->quant_precision = get_bits(gb, 4); /* quant_precision */
5605             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5606             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5607         } else {
5608             s->quant_precision = 5;
5609         }
5610
5611         // FIXME a bunch of grayscale shape things
5612
5613         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5614             int i, v;
5615
5616             /* load default matrixes */
5617             for(i=0; i<64; i++){
5618                 int j= s->dsp.idct_permutation[i];
5619                 v= ff_mpeg4_default_intra_matrix[i];
5620                 s->intra_matrix[j]= v;
5621                 s->chroma_intra_matrix[j]= v;
5622
5623                 v= ff_mpeg4_default_non_intra_matrix[i];
5624                 s->inter_matrix[j]= v;
5625                 s->chroma_inter_matrix[j]= v;
5626             }
5627
5628             /* load custom intra matrix */
5629             if(get_bits1(gb)){
5630                 int last=0;
5631                 for(i=0; i<64; i++){
5632                     int j;
5633                     v= get_bits(gb, 8);
5634                     if(v==0) break;
5635
5636                     last= v;
5637                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5638                     s->intra_matrix[j]= v;
5639                     s->chroma_intra_matrix[j]= v;
5640                 }
5641
5642                 /* replicate last value */
5643                 for(; i<64; i++){
5644                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5645                     s->intra_matrix[j]= last;
5646                     s->chroma_intra_matrix[j]= last;
5647                 }
5648             }
5649
5650             /* load custom non intra matrix */
5651             if(get_bits1(gb)){
5652                 int last=0;
5653                 for(i=0; i<64; i++){
5654                     int j;
5655                     v= get_bits(gb, 8);
5656                     if(v==0) break;
5657
5658                     last= v;
5659                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5660                     s->inter_matrix[j]= v;
5661                     s->chroma_inter_matrix[j]= v;
5662                 }
5663
5664                 /* replicate last value */
5665                 for(; i<64; i++){
5666                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5667                     s->inter_matrix[j]= last;
5668                     s->chroma_inter_matrix[j]= last;
5669                 }
5670             }
5671
5672             // FIXME a bunch of grayscale shape things
5673         }
5674
5675         if(vo_ver_id != 1)
5676              s->quarter_sample= get_bits1(gb);
5677         else s->quarter_sample=0;
5678
5679         if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5680
5681         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5682
5683         s->data_partitioning= get_bits1(gb);
5684         if(s->data_partitioning){
5685             s->rvlc= get_bits1(gb);
5686         }
5687
5688         if(vo_ver_id != 1) {
5689             s->new_pred= get_bits1(gb);
5690             if(s->new_pred){
5691                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5692                 skip_bits(gb, 2); /* requested upstream message type */
5693                 skip_bits1(gb); /* newpred segment type */
5694             }
5695             s->reduced_res_vop= get_bits1(gb);
5696             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5697         }
5698         else{
5699             s->new_pred=0;
5700             s->reduced_res_vop= 0;
5701         }
5702
5703         s->scalability= get_bits1(gb);
5704
5705         if (s->scalability) {
5706             GetBitContext bak= *gb;
5707             int ref_layer_id;
5708             int ref_layer_sampling_dir;
5709             int h_sampling_factor_n;
5710             int h_sampling_factor_m;
5711             int v_sampling_factor_n;
5712             int v_sampling_factor_m;
5713
5714             s->hierachy_type= get_bits1(gb);
5715             ref_layer_id= get_bits(gb, 4);
5716             ref_layer_sampling_dir= get_bits1(gb);
5717             h_sampling_factor_n= get_bits(gb, 5);
5718             h_sampling_factor_m= get_bits(gb, 5);
5719             v_sampling_factor_n= get_bits(gb, 5);
5720             v_sampling_factor_m= get_bits(gb, 5);
5721             s->enhancement_type= get_bits1(gb);
5722
5723             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
5724                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5725
5726 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5727                 s->scalability=0;
5728
5729                 *gb= bak;
5730             }else
5731                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5732
5733             // bin shape stuff FIXME
5734         }
5735     }
5736     return 0;
5737 }
5738
5739 /**
5740  * decodes the user data stuff in the header.
5741  * allso inits divx/xvid/lavc_version/build
5742  */
5743 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5744     char buf[256];
5745     int i;
5746     int e;
5747     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5748     char last;
5749
5750     for(i=0; i<255 && gb->index < gb->size_in_bits; i++){
5751         if(show_bits(gb, 23) == 0) break;
5752         buf[i]= get_bits(gb, 8);
5753     }
5754     buf[i]=0;
5755
5756     /* divx detection */
5757     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5758     if(e<2)
5759         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5760     if(e>=2){
5761         s->divx_version= ver;
5762         s->divx_build= build;
5763         s->divx_packed= e==3 && last=='p';
5764     }
5765
5766     /* ffmpeg detection */
5767     e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5768     if(e!=4)
5769         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5770     if(e!=4){
5771         e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5772         if (e>1)
5773             build= (ver<<16) + (ver2<<8) + ver3;
5774     }
5775     if(e!=4){
5776         if(strcmp(buf, "ffmpeg")==0){
5777             s->lavc_build= 4600;
5778         }
5779     }
5780     if(e==4){
5781         s->lavc_build= build;
5782     }
5783
5784     /* xvid detection */
5785     e=sscanf(buf, "XviD%d", &build);
5786     if(e==1){
5787         s->xvid_build= build;
5788     }
5789
5790 //printf("User Data: %s\n", buf);
5791     return 0;
5792 }
5793
5794 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5795     int time_incr, time_increment;
5796
5797     s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
5798     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5799         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5800         s->low_delay=0;
5801     }
5802
5803     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5804     if(s->partitioned_frame)
5805         s->decode_mb= mpeg4_decode_partitioned_mb;
5806     else
5807         s->decode_mb= ff_mpeg4_decode_mb;
5808
5809     time_incr=0;
5810     while (get_bits1(gb) != 0)
5811         time_incr++;
5812
5813     check_marker(gb, "before time_increment");
5814
5815     if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5816         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5817
5818         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5819             if(show_bits(gb, s->time_increment_bits+1)&1) break;
5820         }
5821
5822         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5823     }
5824
5825     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5826     else time_increment= get_bits(gb, s->time_increment_bits);
5827
5828 //    printf("%d %X\n", s->time_increment_bits, time_increment);
5829 //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);
5830     if(s->pict_type!=B_TYPE){
5831         s->last_time_base= s->time_base;
5832         s->time_base+= time_incr;
5833         s->time= s->time_base*s->avctx->time_base.den + time_increment;
5834         if(s->workaround_bugs&FF_BUG_UMP4){
5835             if(s->time < s->last_non_b_time){
5836 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5837                 s->time_base++;
5838                 s->time+= s->avctx->time_base.den;
5839             }
5840         }
5841         s->pp_time= s->time - s->last_non_b_time;
5842         s->last_non_b_time= s->time;
5843     }else{
5844         s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5845         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5846         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5847 //            printf("messed up order, maybe after seeking? skipping current b frame\n");
5848             return FRAME_SKIPPED;
5849         }
5850
5851         if(s->t_frame==0) s->t_frame= s->pb_time;
5852         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5853         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5854                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5855         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
5856                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5857     }
5858 //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);
5859
5860     if(s->avctx->time_base.num)
5861         s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5862     else
5863         s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5864     if(s->avctx->debug&FF_DEBUG_PTS)
5865         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5866
5867     check_marker(gb, "before vop_coded");
5868
5869     /* vop coded */
5870     if (get_bits1(gb) != 1){
5871         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5872             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5873         return FRAME_SKIPPED;
5874     }
5875 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5876 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5877     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5878                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5879         /* rounding type for motion estimation */
5880         s->no_rounding = get_bits1(gb);
5881     } else {
5882         s->no_rounding = 0;
5883     }
5884 //FIXME reduced res stuff
5885
5886      if (s->shape != RECT_SHAPE) {
5887          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5888              int width, height, hor_spat_ref, ver_spat_ref;
5889
5890              width = get_bits(gb, 13);
5891              skip_bits1(gb);   /* marker */
5892              height = get_bits(gb, 13);
5893              skip_bits1(gb);   /* marker */
5894              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5895              skip_bits1(gb);   /* marker */
5896              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5897          }
5898          skip_bits1(gb); /* change_CR_disable */
5899
5900          if (get_bits1(gb) != 0) {
5901              skip_bits(gb, 8); /* constant_alpha_value */
5902          }
5903      }
5904 //FIXME complexity estimation stuff
5905
5906      if (s->shape != BIN_ONLY_SHAPE) {
5907          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5908          if(!s->progressive_sequence){
5909              s->top_field_first= get_bits1(gb);
5910              s->alternate_scan= get_bits1(gb);
5911          }else
5912              s->alternate_scan= 0;
5913      }
5914
5915      if(s->alternate_scan){
5916          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
5917          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
5918          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5919          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5920      } else{
5921          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
5922          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
5923          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5924          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5925      }
5926
5927      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5928          mpeg4_decode_sprite_trajectory(s, gb);
5929          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5930          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5931      }
5932
5933      if (s->shape != BIN_ONLY_SHAPE) {
5934          s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5935          if(s->qscale==0){
5936              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5937              return -1; // makes no sense to continue, as there is nothing left from the image then
5938          }
5939
5940          if (s->pict_type != I_TYPE) {
5941              s->f_code = get_bits(gb, 3);       /* fcode_for */
5942              if(s->f_code==0){
5943                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5944                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
5945              }
5946          }else
5947              s->f_code=1;
5948
5949          if (s->pict_type == B_TYPE) {
5950              s->b_code = get_bits(gb, 3);
5951          }else
5952              s->b_code=1;
5953
5954          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5955              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",
5956                  s->qscale, s->f_code, s->b_code,
5957                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5958                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5959                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5960                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5961          }
5962
5963          if(!s->scalability){
5964              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5965                  skip_bits1(gb); // vop shape coding type
5966              }
5967          }else{
5968              if(s->enhancement_type){
5969                  int load_backward_shape= get_bits1(gb);
5970                  if(load_backward_shape){
5971                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
5972                  }
5973              }
5974              skip_bits(gb, 2); //ref_select_code
5975          }
5976      }
5977      /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
5978      // note we cannot detect divx5 without b-frames easily (although it's buggy too)
5979      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5980          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5981          s->low_delay=1;
5982      }
5983
5984      s->picture_number++; // better than pic number==0 always ;)
5985
5986      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5987      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5988
5989      if(s->workaround_bugs&FF_BUG_EDGE){
5990          s->h_edge_pos= s->width;
5991          s->v_edge_pos= s->height;
5992      }
5993      return 0;
5994 }
5995
5996 /**
5997  * decode mpeg4 headers
5998  * @return <0 if no VOP found (or a damaged one)
5999  *         FRAME_SKIPPED if a not coded VOP is found
6000  *         0 if a VOP is found
6001  */
6002 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6003 {
6004     int startcode, v;
6005
6006     /* search next start code */
6007     align_get_bits(gb);
6008
6009     if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6010         skip_bits(gb, 24);
6011         if(get_bits(gb, 8) == 0xF0)
6012             return decode_vop_header(s, gb);
6013     }
6014
6015     startcode = 0xff;
6016     for(;;) {
6017         if(get_bits_count(gb) >= gb->size_in_bits){
6018             if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6019                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6020                 return FRAME_SKIPPED; //divx bug
6021             }else
6022                 return -1; //end of stream
6023         }
6024
6025         /* use the bits after the test */
6026         v = get_bits(gb, 8);
6027         startcode = ((startcode << 8) | v) & 0xffffffff;
6028
6029         if((startcode&0xFFFFFF00) != 0x100)
6030             continue; //no startcode
6031
6032         if(s->avctx->debug&FF_DEBUG_STARTCODE){
6033             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6034             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6035             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6036             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6037             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6038             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6039             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6040             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6041             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6042             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6043             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6044             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6045             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6046             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6047             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6048             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6049             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6050             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6051             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6052             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6053             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6054             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6055             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6056             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6057             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6058             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6059             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6060             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6061             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6062         }
6063
6064         if(startcode >= 0x120 && startcode <= 0x12F){
6065             if(decode_vol_header(s, gb) < 0)
6066                 return -1;
6067         }
6068         else if(startcode == USER_DATA_STARTCODE){
6069             decode_user_data(s, gb);
6070         }
6071         else if(startcode == GOP_STARTCODE){
6072             mpeg4_decode_gop_header(s, gb);
6073         }
6074         else if(startcode == VOP_STARTCODE){
6075             return decode_vop_header(s, gb);
6076         }
6077
6078         align_get_bits(gb);
6079         startcode = 0xff;
6080     }
6081 }
6082
6083 /* don't understand why they choose a different header ! */
6084 int intel_h263_decode_picture_header(MpegEncContext *s)
6085 {
6086     int format;
6087
6088     /* picture header */
6089     if (get_bits_long(&s->gb, 22) != 0x20) {
6090         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6091         return -1;
6092     }
6093     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6094
6095     if (get_bits1(&s->gb) != 1) {
6096         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6097         return -1;      /* marker */
6098     }
6099     if (get_bits1(&s->gb) != 0) {
6100         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6101         return -1;      /* h263 id */
6102     }
6103     skip_bits1(&s->gb);         /* split screen off */
6104     skip_bits1(&s->gb);         /* camera  off */
6105     skip_bits1(&s->gb);         /* freeze picture release off */
6106
6107     format = get_bits(&s->gb, 3);
6108     if (format != 7) {
6109         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6110         return -1;
6111     }
6112     s->h263_plus = 0;
6113
6114     s->pict_type = I_TYPE + get_bits1(&s->gb);
6115
6116     s->unrestricted_mv = get_bits1(&s->gb);
6117     s->h263_long_vectors = s->unrestricted_mv;
6118
6119     if (get_bits1(&s->gb) != 0) {
6120         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6121         return -1;      /* SAC: off */
6122     }
6123     if (get_bits1(&s->gb) != 0) {
6124         s->obmc= 1;
6125         av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6126 //        return -1;      /* advanced prediction mode: off */
6127     }
6128     if (get_bits1(&s->gb) != 0) {
6129         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6130         return -1;      /* PB frame mode */
6131     }
6132
6133     /* skip unknown header garbage */
6134     skip_bits(&s->gb, 41);
6135
6136     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6137     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6138
6139     /* PEI */
6140     while (get_bits1(&s->gb) != 0) {
6141         skip_bits(&s->gb, 8);
6142     }
6143     s->f_code = 1;
6144
6145     s->y_dc_scale_table=
6146     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6147
6148     return 0;
6149 }
6150
6151 int flv_h263_decode_picture_header(MpegEncContext *s)
6152 {
6153     int format, width, height;
6154
6155     /* picture header */
6156     if (get_bits_long(&s->gb, 17) != 1) {
6157         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6158         return -1;
6159     }
6160     format = get_bits(&s->gb, 5);
6161     if (format != 0 && format != 1) {
6162         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6163         return -1;
6164     }
6165     s->h263_flv = format+1;
6166     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6167     format = get_bits(&s->gb, 3);
6168     switch (format) {
6169     case 0:
6170         width = get_bits(&s->gb, 8);
6171         height = get_bits(&s->gb, 8);
6172         break;
6173     case 1:
6174         width = get_bits(&s->gb, 16);
6175         height = get_bits(&s->gb, 16);
6176         break;
6177     case 2:
6178         width = 352;
6179         height = 288;
6180         break;
6181     case 3:
6182         width = 176;
6183         height = 144;
6184         break;
6185     case 4:
6186         width = 128;
6187         height = 96;
6188         break;
6189     case 5:
6190         width = 320;
6191         height = 240;
6192         break;
6193     case 6:
6194         width = 160;
6195         height = 120;
6196         break;
6197     default:
6198         width = height = 0;
6199         break;
6200     }
6201     if(avcodec_check_dimensions(s->avctx, width, height))
6202         return -1;
6203     s->width = width;
6204     s->height = height;
6205
6206     s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6207     s->dropable= s->pict_type > P_TYPE;
6208     if (s->dropable)
6209         s->pict_type = P_TYPE;
6210
6211     skip_bits1(&s->gb); /* deblocking flag */
6212     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6213
6214     s->h263_plus = 0;
6215
6216     s->unrestricted_mv = 1;
6217     s->h263_long_vectors = 0;
6218
6219     /* PEI */
6220     while (get_bits1(&s->gb) != 0) {
6221         skip_bits(&s->gb, 8);
6222     }
6223     s->f_code = 1;
6224
6225     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6226         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6227                s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6228     }
6229
6230     s->y_dc_scale_table=
6231     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6232
6233     return 0;
6234 }