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