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

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