libavcodec/h263.c

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