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