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