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

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