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

   1 /*
   2  * H263/MPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard.
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P.
   6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * ac prediction encoding, B-frame support, error resilience, optimizations,
   9  * qpel decoding, gmc decoding, interlaced decoding
  10  * by Michael Niedermayer <michaelni@gmx.at>
  11  *
  12  * This file is part of FFmpeg.
  13  *
  14  * FFmpeg is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2.1 of the License, or (at your option) any later version.
  18  *
  19  * FFmpeg is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with FFmpeg; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  27  */
  28
  29 /**
  30  * @file h263.c
  31  * h263/mpeg4 codec.
  32  */
  33
  34 //#define DEBUG
  35 #include <limits.h>
  36
  37 #include "dsputil.h"
  38 #include "avcodec.h"
  39 #include "mpegvideo.h"
  40 #include "h263data.h"
  41 #include "mpeg4data.h"
  42
  43 //#undef NDEBUG
  44 //#include <assert.h>
  45
  46 #define INTRA_MCBPC_VLC_BITS 6
  47 #define INTER_MCBPC_VLC_BITS 7
  48 #define CBPY_VLC_BITS 6
  49 #define MV_VLC_BITS 9
  50 #define DC_VLC_BITS 9
  51 #define SPRITE_TRAJ_VLC_BITS 6
  52 #define MB_TYPE_B_VLC_BITS 4
  53 #define TEX_VLC_BITS 9
  54 #define H263_MBTYPE_B_VLC_BITS 6
  55 #define CBPC_B_VLC_BITS 3
  56
  57 #ifdef CONFIG_ENCODERS
  58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  59                               int n);
  60 static void h263p_encode_umotion(MpegEncContext * s, int val);
  61 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  62                                int n, int dc, uint8_t *scan_table,
  63                                PutBitContext *dc_pb, PutBitContext *ac_pb);
  64 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
  65                                   uint8_t *scan_table);
  66 #endif
  67
  68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
  69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
  70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  71                              int n, int coded);
  72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
  73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  74                               int n, int coded, int intra, int rvlc);
  75 #ifdef CONFIG_ENCODERS
  76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
  77 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
  78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
  79 #endif //CONFIG_ENCODERS
  80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
  81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
  82
  83 #ifdef CONFIG_ENCODERS
  84 static uint8_t uni_DCtab_lum_len[512];
  85 static uint8_t uni_DCtab_chrom_len[512];
  86 static uint16_t uni_DCtab_lum_bits[512];
  87 static uint16_t uni_DCtab_chrom_bits[512];
  88
  89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  90 static uint8_t fcode_tab[MAX_MV*2+1];
  91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
  92
  93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
  94 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
  95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
  96 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
  97 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
  98 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
  99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
 100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
 101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
 102
 103 /* mpeg4
 104 inter
 105 max level: 24/6
 106 max run: 53/63
 107
 108 intra
 109 max level: 53/16
 110 max run: 29/41
 111 */
 112 #endif
 113
 114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
 115
 116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
 117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
 118 #else
 119 #define IS_3IV1 0
 120 #endif
 121
 122 int h263_get_picture_format(int width, int height)
 123 {
 124     int format;
 125
 126     if (width == 128 && height == 96)
 127         format = 1;
 128     else if (width == 176 && height == 144)
 129         format = 2;
 130     else if (width == 352 && height == 288)
 131         format = 3;
 132     else if (width == 704 && height == 576)
 133         format = 4;
 134     else if (width == 1408 && height == 1152)
 135         format = 5;
 136     else
 137         format = 7;
 138     return format;
 139 }
 140
 141 #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){
2263     if(s->pict_type==B_TYPE){
2264         ff_mpeg4_init_direct_mv(s);
2265     }else{
2266         s->last_time_base= s->time_base;
2267         s->time_base= s->time/s->avctx->time_base.den;
2268     }
2269 }
2270
2271 static void mpeg4_encode_gop_header(MpegEncContext * s){
2272     int hours, minutes, seconds;
2273     int64_t time;
2274
2275     put_bits(&s->pb, 16, 0);
2276     put_bits(&s->pb, 16, GOP_STARTCODE);
2277
2278     time= s->current_picture_ptr->pts;
2279     if(s->reordered_input_picture[1])
2280         time= FFMIN(time, s->reordered_input_picture[1]->pts);
2281     time= time*s->avctx->time_base.num;
2282
2283     seconds= time/s->avctx->time_base.den;
2284     minutes= seconds/60; seconds %= 60;
2285     hours= minutes/60; minutes %= 60;
2286     hours%=24;
2287
2288     put_bits(&s->pb, 5, hours);
2289     put_bits(&s->pb, 6, minutes);
2290     put_bits(&s->pb, 1, 1);
2291     put_bits(&s->pb, 6, seconds);
2292
2293     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2294     put_bits(&s->pb, 1, 0); //broken link == NO
2295
2296     s->last_time_base= time / s->avctx->time_base.den;
2297
2298     ff_mpeg4_stuffing(&s->pb);
2299 }
2300
2301 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2302     int profile_and_level_indication;
2303     int vo_ver_id;
2304
2305     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2306         profile_and_level_indication = s->avctx->profile << 4;
2307     }else if(s->max_b_frames || s->quarter_sample){
2308         profile_and_level_indication= 0xF0; // adv simple
2309     }else{
2310         profile_and_level_indication= 0x00; // simple
2311     }
2312
2313     if(s->avctx->level != FF_LEVEL_UNKNOWN){
2314         profile_and_level_indication |= s->avctx->level;
2315     }else{
2316         profile_and_level_indication |= 1; //level 1
2317     }
2318
2319     if(profile_and_level_indication>>4 == 0xF){
2320         vo_ver_id= 5;
2321     }else{
2322         vo_ver_id= 1;
2323     }
2324
2325     //FIXME levels
2326
2327     put_bits(&s->pb, 16, 0);
2328     put_bits(&s->pb, 16, VOS_STARTCODE);
2329
2330     put_bits(&s->pb, 8, profile_and_level_indication);
2331
2332     put_bits(&s->pb, 16, 0);
2333     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2334
2335     put_bits(&s->pb, 1, 1);
2336         put_bits(&s->pb, 4, vo_ver_id);
2337         put_bits(&s->pb, 3, 1); //priority
2338
2339     put_bits(&s->pb, 4, 1); //visual obj type== video obj
2340
2341     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2342
2343     ff_mpeg4_stuffing(&s->pb);
2344 }
2345
2346 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2347 {
2348     int vo_ver_id;
2349
2350     if(s->max_b_frames || s->quarter_sample){
2351         vo_ver_id= 5;
2352         s->vo_type= ADV_SIMPLE_VO_TYPE;
2353     }else{
2354         vo_ver_id= 1;
2355         s->vo_type= SIMPLE_VO_TYPE;
2356     }
2357
2358     put_bits(&s->pb, 16, 0);
2359     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2360     put_bits(&s->pb, 16, 0);
2361     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2362
2363     put_bits(&s->pb, 1, 0);             /* random access vol */
2364     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2365     if(s->workaround_bugs & FF_BUG_MS) {
2366         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2367     } else {
2368         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2369         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2370         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2371     }
2372
2373     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2374
2375     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2376     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2377         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2378         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2379     }
2380
2381     if(s->workaround_bugs & FF_BUG_MS) { //
2382         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2383     } else {
2384         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2385         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2386         put_bits(&s->pb, 1, s->low_delay);
2387         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2388     }
2389
2390     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2391     put_bits(&s->pb, 1, 1);             /* marker bit */
2392
2393     put_bits(&s->pb, 16, s->avctx->time_base.den);
2394     if (s->time_increment_bits < 1)
2395         s->time_increment_bits = 1;
2396     put_bits(&s->pb, 1, 1);             /* marker bit */
2397     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2398     put_bits(&s->pb, 1, 1);             /* marker bit */
2399     put_bits(&s->pb, 13, s->width);     /* vol width */
2400     put_bits(&s->pb, 1, 1);             /* marker bit */
2401     put_bits(&s->pb, 13, s->height);    /* vol height */
2402     put_bits(&s->pb, 1, 1);             /* marker bit */
2403     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2404     put_bits(&s->pb, 1, 1);             /* obmc disable */
2405     if (vo_ver_id == 1) {
2406         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2407     }else{
2408         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2409     }
2410
2411     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2412     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2413
2414     if(s->mpeg_quant){
2415         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2416         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2417     }
2418
2419     if (vo_ver_id != 1)
2420         put_bits(&s->pb, 1, s->quarter_sample);
2421     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2422     s->resync_marker= s->rtp_mode;
2423     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2424     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2425     if(s->data_partitioning){
2426         put_bits(&s->pb, 1, 0);         /* no rvlc */
2427     }
2428
2429     if (vo_ver_id != 1){
2430         put_bits(&s->pb, 1, 0);         /* newpred */
2431         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2432     }
2433     put_bits(&s->pb, 1, 0);             /* scalability */
2434
2435     ff_mpeg4_stuffing(&s->pb);
2436
2437     /* user data */
2438     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2439         put_bits(&s->pb, 16, 0);
2440         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2441         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2442     }
2443 }
2444
2445 /* write mpeg4 VOP header */
2446 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2447 {
2448     int time_incr;
2449     int time_div, time_mod;
2450
2451     if (!ENABLE_MPEG4_ENCODER)  return;
2452
2453     if(s->pict_type==I_TYPE){
2454         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2455             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2456                 mpeg4_encode_visual_object_header(s);
2457             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2458                 mpeg4_encode_vol_header(s, 0, 0);
2459         }
2460         if(!(s->workaround_bugs & FF_BUG_MS))
2461             mpeg4_encode_gop_header(s);
2462     }
2463
2464     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2465
2466 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2467
2468     put_bits(&s->pb, 16, 0);                /* vop header */
2469     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2470     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2471
2472     assert(s->time>=0);
2473     time_div= s->time/s->avctx->time_base.den;
2474     time_mod= s->time%s->avctx->time_base.den;
2475     time_incr= time_div - s->last_time_base;
2476     assert(time_incr >= 0);
2477     while(time_incr--)
2478         put_bits(&s->pb, 1, 1);
2479
2480     put_bits(&s->pb, 1, 0);
2481
2482     put_bits(&s->pb, 1, 1);                             /* marker */
2483     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2484     put_bits(&s->pb, 1, 1);                             /* marker */
2485     put_bits(&s->pb, 1, 1);                             /* vop coded */
2486     if (    s->pict_type == P_TYPE
2487         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2488         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2489     }
2490     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2491     if(!s->progressive_sequence){
2492          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2493          put_bits(&s->pb, 1, s->alternate_scan);
2494     }
2495     //FIXME sprite stuff
2496
2497     put_bits(&s->pb, 5, s->qscale);
2498
2499     if (s->pict_type != I_TYPE)
2500         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2501     if (s->pict_type == B_TYPE)
2502         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2503     //    printf("****frame %d\n", picture_number);
2504 }
2505
2506 #endif //CONFIG_ENCODERS
2507
2508 /**
2509  * predicts the dc.
2510  * encoding quantized level -> quantized diff
2511  * decoding quantized diff -> quantized level
2512  * @param n block index (0-3 are luma, 4-5 are chroma)
2513  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2514  */
2515 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2516 {
2517     int a, b, c, wrap, pred, scale, ret;
2518     int16_t *dc_val;
2519
2520     /* find prediction */
2521     if (n < 4) {
2522         scale = s->y_dc_scale;
2523     } else {
2524         scale = s->c_dc_scale;
2525     }
2526     if(IS_3IV1)
2527         scale= 8;
2528
2529     wrap= s->block_wrap[n];
2530     dc_val = s->dc_val[0] + s->block_index[n];
2531
2532     /* B C
2533      * A X
2534      */
2535     a = dc_val[ - 1];
2536     b = dc_val[ - 1 - wrap];
2537     c = dc_val[ - wrap];
2538
2539     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2540     if(s->first_slice_line && n!=3){
2541         if(n!=2) b=c= 1024;
2542         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2543     }
2544     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2545         if(n==0 || n==4 || n==5)
2546             b=1024;
2547     }
2548
2549     if (abs(a - b) < abs(b - c)) {
2550         pred = c;
2551         *dir_ptr = 1; /* top */
2552     } else {
2553         pred = a;
2554         *dir_ptr = 0; /* left */
2555     }
2556     /* we assume pred is positive */
2557     pred = FASTDIV((pred + (scale >> 1)), scale);
2558
2559     if(encoding){
2560         ret = level - pred;
2561     }else{
2562         level += pred;
2563         ret= level;
2564         if(s->error_resilience>=3){
2565             if(level<0){
2566                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2567                 return -1;
2568             }
2569             if(level*scale > 2048 + scale){
2570                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2571                 return -1;
2572             }
2573         }
2574     }
2575     level *=scale;
2576     if(level&(~2047)){
2577         if(level<0)
2578             level=0;
2579         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2580             level=2047;
2581     }
2582     dc_val[0]= level;
2583
2584     return ret;
2585 }
2586
2587 /**
2588  * predicts the ac.
2589  * @param n block index (0-3 are luma, 4-5 are chroma)
2590  * @param dir the ac prediction direction
2591  */
2592 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2593                    int dir)
2594 {
2595     int i;
2596     int16_t *ac_val, *ac_val1;
2597     int8_t * const qscale_table= s->current_picture.qscale_table;
2598
2599     /* find prediction */
2600     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2601     ac_val1 = ac_val;
2602     if (s->ac_pred) {
2603         if (dir == 0) {
2604             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2605             /* left prediction */
2606             ac_val -= 16;
2607
2608             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2609                 /* same qscale */
2610                 for(i=1;i<8;i++) {
2611                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2612                 }
2613             }else{
2614                 /* different qscale, we must rescale */
2615                 for(i=1;i<8;i++) {
2616                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2617                 }
2618             }
2619         } else {
2620             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2621             /* top prediction */
2622             ac_val -= 16 * s->block_wrap[n];
2623
2624             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2625                 /* same qscale */
2626                 for(i=1;i<8;i++) {
2627                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2628                 }
2629             }else{
2630                 /* different qscale, we must rescale */
2631                 for(i=1;i<8;i++) {
2632                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2633                 }
2634             }
2635         }
2636     }
2637     /* left copy */
2638     for(i=1;i<8;i++)
2639         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2640
2641     /* top copy */
2642     for(i=1;i<8;i++)
2643         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2644
2645 }
2646
2647 #ifdef CONFIG_ENCODERS
2648
2649 /**
2650  * encodes the dc value.
2651  * @param n block index (0-3 are luma, 4-5 are chroma)
2652  */
2653 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2654 {
2655 #if 1
2656 //    if(level<-255 || level>255) printf("dc overflow\n");
2657     level+=256;
2658     if (n < 4) {
2659         /* luminance */
2660         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2661     } else {
2662         /* chrominance */
2663         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2664     }
2665 #else
2666     int size, v;
2667     /* find number of bits */
2668     size = 0;
2669     v = abs(level);
2670     while (v) {
2671         v >>= 1;
2672         size++;
2673     }
2674
2675     if (n < 4) {
2676         /* luminance */
2677         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2678     } else {
2679         /* chrominance */
2680         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2681     }
2682
2683     /* encode remaining bits */
2684     if (size > 0) {
2685         if (level < 0)
2686             level = (-level) ^ ((1 << size) - 1);
2687         put_bits(&s->pb, size, level);
2688         if (size > 8)
2689             put_bits(&s->pb, 1, 1);
2690     }
2691 #endif
2692 }
2693
2694 static inline int mpeg4_get_dc_length(int level, int n){
2695     if (n < 4) {
2696         return uni_DCtab_lum_len[level + 256];
2697     } else {
2698         return uni_DCtab_chrom_len[level + 256];
2699     }
2700 }
2701
2702 /**
2703  * encodes a 8x8 block
2704  * @param n block index (0-3 are luma, 4-5 are chroma)
2705  */
2706 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2707                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2708 {
2709     int i, last_non_zero;
2710 #if 0 //variables for the outcommented version
2711     int code, sign, last;
2712 #endif
2713     const RLTable *rl;
2714     uint32_t *bits_tab;
2715     uint8_t *len_tab;
2716     const int last_index = s->block_last_index[n];
2717
2718     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2719         /* mpeg4 based DC predictor */
2720         mpeg4_encode_dc(dc_pb, intra_dc, n);
2721         if(last_index<1) return;
2722         i = 1;
2723         rl = &rl_intra;
2724         bits_tab= uni_mpeg4_intra_rl_bits;
2725         len_tab = uni_mpeg4_intra_rl_len;
2726     } else {
2727         if(last_index<0) return;
2728         i = 0;
2729         rl = &rl_inter;
2730         bits_tab= uni_mpeg4_inter_rl_bits;
2731         len_tab = uni_mpeg4_inter_rl_len;
2732     }
2733
2734     /* AC coefs */
2735     last_non_zero = i - 1;
2736 #if 1
2737     for (; i < last_index; i++) {
2738         int level = block[ scan_table[i] ];
2739         if (level) {
2740             int run = i - last_non_zero - 1;
2741             level+=64;
2742             if((level&(~127)) == 0){
2743                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2744                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2745             }else{ //ESC3
2746                 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);
2747             }
2748             last_non_zero = i;
2749         }
2750     }
2751     /*if(i<=last_index)*/{
2752         int level = block[ scan_table[i] ];
2753         int run = i - last_non_zero - 1;
2754         level+=64;
2755         if((level&(~127)) == 0){
2756             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2757             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2758         }else{ //ESC3
2759             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);
2760         }
2761     }
2762 #else
2763     for (; i <= last_index; i++) {
2764         const int slevel = block[ scan_table[i] ];
2765         if (slevel) {
2766             int level;
2767             int run = i - last_non_zero - 1;
2768             last = (i == last_index);
2769             sign = 0;
2770             level = slevel;
2771             if (level < 0) {
2772                 sign = 1;
2773                 level = -level;
2774             }
2775             code = get_rl_index(rl, last, run, level);
2776             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2777             if (code == rl->n) {
2778                 int level1, run1;
2779                 level1 = level - rl->max_level[last][run];
2780                 if (level1 < 1)
2781                     goto esc2;
2782                 code = get_rl_index(rl, last, run, level1);
2783                 if (code == rl->n) {
2784                 esc2:
2785                     put_bits(ac_pb, 1, 1);
2786                     if (level > MAX_LEVEL)
2787                         goto esc3;
2788                     run1 = run - rl->max_run[last][level] - 1;
2789                     if (run1 < 0)
2790                         goto esc3;
2791                     code = get_rl_index(rl, last, run1, level);
2792                     if (code == rl->n) {
2793                     esc3:
2794                         /* third escape */
2795                         put_bits(ac_pb, 1, 1);
2796                         put_bits(ac_pb, 1, last);
2797                         put_bits(ac_pb, 6, run);
2798                         put_bits(ac_pb, 1, 1);
2799                         put_bits(ac_pb, 12, slevel & 0xfff);
2800                         put_bits(ac_pb, 1, 1);
2801                     } else {
2802                         /* second escape */
2803                         put_bits(ac_pb, 1, 0);
2804                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2805                         put_bits(ac_pb, 1, sign);
2806                     }
2807                 } else {
2808                     /* first escape */
2809                     put_bits(ac_pb, 1, 0);
2810                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2811                     put_bits(ac_pb, 1, sign);
2812                 }
2813             } else {
2814                 put_bits(ac_pb, 1, sign);
2815             }
2816             last_non_zero = i;
2817         }
2818     }
2819 #endif
2820 }
2821
2822 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2823                                uint8_t *scan_table)
2824 {
2825     int i, last_non_zero;
2826     const RLTable *rl;
2827     uint8_t *len_tab;
2828     const int last_index = s->block_last_index[n];
2829     int len=0;
2830
2831     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2832         /* mpeg4 based DC predictor */
2833         len += mpeg4_get_dc_length(intra_dc, n);
2834         if(last_index<1) return len;
2835         i = 1;
2836         rl = &rl_intra;
2837         len_tab = uni_mpeg4_intra_rl_len;
2838     } else {
2839         if(last_index<0) return 0;
2840         i = 0;
2841         rl = &rl_inter;
2842         len_tab = uni_mpeg4_inter_rl_len;
2843     }
2844
2845     /* AC coefs */
2846     last_non_zero = i - 1;
2847     for (; i < last_index; i++) {
2848         int level = block[ scan_table[i] ];
2849         if (level) {
2850             int run = i - last_non_zero - 1;
2851             level+=64;
2852             if((level&(~127)) == 0){
2853                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2854                 len += len_tab[index];
2855             }else{ //ESC3
2856                 len += 7+2+1+6+1+12+1;
2857             }
2858             last_non_zero = i;
2859         }
2860     }
2861     /*if(i<=last_index)*/{
2862         int level = block[ scan_table[i] ];
2863         int run = i - last_non_zero - 1;
2864         level+=64;
2865         if((level&(~127)) == 0){
2866             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2867             len += len_tab[index];
2868         }else{ //ESC3
2869             len += 7+2+1+6+1+12+1;
2870         }
2871     }
2872
2873     return len;
2874 }
2875
2876 #endif
2877
2878
2879 /***********************************************/
2880 /* decoding */
2881
2882 static VLC intra_MCBPC_vlc;
2883 static VLC inter_MCBPC_vlc;
2884 static VLC cbpy_vlc;
2885 static VLC mv_vlc;
2886 static VLC dc_lum, dc_chrom;
2887 static VLC sprite_trajectory;
2888 static VLC mb_type_b_vlc;
2889 static VLC h263_mbtype_b_vlc;
2890 static VLC cbpc_b_vlc;
2891
2892 /* init vlcs */
2893
2894 /* XXX: find a better solution to handle static init */
2895 void h263_decode_init_vlc(MpegEncContext *s)
2896 {
2897     static int done = 0;
2898
2899     if (!done) {
2900         done = 1;
2901
2902         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2903                  intra_MCBPC_bits, 1, 1,
2904                  intra_MCBPC_code, 1, 1, 1);
2905         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2906                  inter_MCBPC_bits, 1, 1,
2907                  inter_MCBPC_code, 1, 1, 1);
2908         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2909                  &cbpy_tab[0][1], 2, 1,
2910                  &cbpy_tab[0][0], 2, 1, 1);
2911         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2912                  &mvtab[0][1], 2, 1,
2913                  &mvtab[0][0], 2, 1, 1);
2914         init_rl(&rl_inter, static_rl_table_store[0]);
2915         init_rl(&rl_intra, static_rl_table_store[1]);
2916         init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2917         init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2918         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2919         init_vlc_rl(&rl_inter, 1);
2920         init_vlc_rl(&rl_intra, 1);
2921         init_vlc_rl(&rvlc_rl_inter, 1);
2922         init_vlc_rl(&rvlc_rl_intra, 1);
2923         init_vlc_rl(&rl_intra_aic, 1);
2924         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2925                  &DCtab_lum[0][1], 2, 1,
2926                  &DCtab_lum[0][0], 2, 1, 1);
2927         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2928                  &DCtab_chrom[0][1], 2, 1,
2929                  &DCtab_chrom[0][0], 2, 1, 1);
2930         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2931                  &sprite_trajectory_tab[0][1], 4, 2,
2932                  &sprite_trajectory_tab[0][0], 4, 2, 1);
2933         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2934                  &mb_type_b_tab[0][1], 2, 1,
2935                  &mb_type_b_tab[0][0], 2, 1, 1);
2936         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2937                  &h263_mbtype_b_tab[0][1], 2, 1,
2938                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
2939         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2940                  &cbpc_b_tab[0][1], 2, 1,
2941                  &cbpc_b_tab[0][0], 2, 1, 1);
2942     }
2943 }
2944
2945 /**
2946  * Get the GOB height based on picture height.
2947  */
2948 int ff_h263_get_gob_height(MpegEncContext *s){
2949     if (s->height <= 400)
2950         return 1;
2951     else if (s->height <= 800)
2952         return  2;
2953     else
2954         return 4;
2955 }
2956
2957 int ff_h263_decode_mba(MpegEncContext *s)
2958 {
2959     int i, mb_pos;
2960
2961     for(i=0; i<6; i++){
2962         if(s->mb_num-1 <= ff_mba_max[i]) break;
2963     }
2964     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2965     s->mb_x= mb_pos % s->mb_width;
2966     s->mb_y= mb_pos / s->mb_width;
2967
2968     return mb_pos;
2969 }
2970
2971 void ff_h263_encode_mba(MpegEncContext *s)
2972 {
2973     int i, mb_pos;
2974
2975     for(i=0; i<6; i++){
2976         if(s->mb_num-1 <= ff_mba_max[i]) break;
2977     }
2978     mb_pos= s->mb_x + s->mb_width*s->mb_y;
2979     put_bits(&s->pb, ff_mba_length[i], mb_pos);
2980 }
2981
2982 /**
2983  * decodes the group of blocks header or slice header.
2984  * @return <0 if an error occured
2985  */
2986 static int h263_decode_gob_header(MpegEncContext *s)
2987 {
2988     unsigned int val, gfid, gob_number;
2989     int left;
2990
2991     /* Check for GOB Start Code */
2992     val = show_bits(&s->gb, 16);
2993     if(val)
2994         return -1;
2995
2996         /* We have a GBSC probably with GSTUFF */
2997     skip_bits(&s->gb, 16); /* Drop the zeros */
2998     left= s->gb.size_in_bits - get_bits_count(&s->gb);
2999     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3000     for(;left>13; left--){
3001         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3002     }
3003     if(left<=13)
3004         return -1;
3005
3006     if(s->h263_slice_structured){
3007         if(get_bits1(&s->gb)==0)
3008             return -1;
3009
3010         ff_h263_decode_mba(s);
3011
3012         if(s->mb_num > 1583)
3013             if(get_bits1(&s->gb)==0)
3014                 return -1;
3015
3016         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3017         if(get_bits1(&s->gb)==0)
3018             return -1;
3019         gfid = get_bits(&s->gb, 2); /* GFID */
3020     }else{
3021         gob_number = get_bits(&s->gb, 5); /* GN */
3022         s->mb_x= 0;
3023         s->mb_y= s->gob_index* gob_number;
3024         gfid = get_bits(&s->gb, 2); /* GFID */
3025         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3026     }
3027
3028     if(s->mb_y >= s->mb_height)
3029         return -1;
3030
3031     if(s->qscale==0)
3032         return -1;
3033
3034     return 0;
3035 }
3036
3037 static inline void memsetw(short *tab, int val, int n)
3038 {
3039     int i;
3040     for(i=0;i<n;i++)
3041         tab[i] = val;
3042 }
3043
3044 #ifdef CONFIG_ENCODERS
3045
3046 void ff_mpeg4_init_partitions(MpegEncContext *s)
3047 {
3048     uint8_t *start= pbBufPtr(&s->pb);
3049     uint8_t *end= s->pb.buf_end;
3050     int size= end - start;
3051     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3052     int tex_size= (size - 2*pb_size)&(~3);
3053
3054     set_put_bits_buffer_size(&s->pb, pb_size);
3055     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3056     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3057 }
3058
3059 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3060 {
3061     const int pb2_len   = put_bits_count(&s->pb2   );
3062     const int tex_pb_len= put_bits_count(&s->tex_pb);
3063     const int bits= put_bits_count(&s->pb);
3064
3065     if(s->pict_type==I_TYPE){
3066         put_bits(&s->pb, 19, DC_MARKER);
3067         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3068         s->i_tex_bits+= tex_pb_len;
3069     }else{
3070         put_bits(&s->pb, 17, MOTION_MARKER);
3071         s->misc_bits+=17 + pb2_len;
3072         s->mv_bits+= bits - s->last_bits;
3073         s->p_tex_bits+= tex_pb_len;
3074     }
3075
3076     flush_put_bits(&s->pb2);
3077     flush_put_bits(&s->tex_pb);
3078
3079     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3080     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3081     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3082     s->last_bits= put_bits_count(&s->pb);
3083 }
3084
3085 #endif //CONFIG_ENCODERS
3086
3087 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3088     switch(s->pict_type){
3089         case I_TYPE:
3090             return 16;
3091         case P_TYPE:
3092         case S_TYPE:
3093             return s->f_code+15;
3094         case B_TYPE:
3095             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3096         default:
3097             return -1;
3098     }
3099 }
3100
3101 #ifdef CONFIG_ENCODERS
3102
3103 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3104 {
3105     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3106
3107     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3108     put_bits(&s->pb, 1, 1);
3109
3110     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3111     put_bits(&s->pb, s->quant_precision, s->qscale);
3112     put_bits(&s->pb, 1, 0); /* no HEC */
3113 }
3114
3115 #endif //CONFIG_ENCODERS
3116
3117 /**
3118  * check if the next stuff is a resync marker or the end.
3119  * @return 0 if not
3120  */
3121 static inline int mpeg4_is_resync(MpegEncContext *s){
3122     int bits_count= get_bits_count(&s->gb);
3123     int v= show_bits(&s->gb, 16);
3124
3125     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3126         return 0;
3127     }
3128
3129     while(v<=0xFF){
3130         if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3131             break;
3132         skip_bits(&s->gb, 8+s->pict_type);
3133         bits_count+= 8+s->pict_type;
3134         v= show_bits(&s->gb, 16);
3135     }
3136
3137     if(bits_count + 8 >= s->gb.size_in_bits){
3138         v>>=8;
3139         v|= 0x7F >> (7-(bits_count&7));
3140
3141         if(v==0x7F)
3142             return 1;
3143     }else{
3144         if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3145             int len;
3146             GetBitContext gb= s->gb;
3147
3148             skip_bits(&s->gb, 1);
3149             align_get_bits(&s->gb);
3150
3151             for(len=0; len<32; len++){
3152                 if(get_bits1(&s->gb)) break;
3153             }
3154
3155             s->gb= gb;
3156
3157             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3158                 return 1;
3159         }
3160     }
3161     return 0;
3162 }
3163
3164 /**
3165  * decodes the next video packet.
3166  * @return <0 if something went wrong
3167  */
3168 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3169 {
3170     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3171     int header_extension=0, mb_num, len;
3172
3173     /* is there enough space left for a video packet + header */
3174     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3175
3176     for(len=0; len<32; len++){
3177         if(get_bits1(&s->gb)) break;
3178     }
3179
3180     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3181         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3182         return -1;
3183     }
3184
3185     if(s->shape != RECT_SHAPE){
3186         header_extension= get_bits1(&s->gb);
3187         //FIXME more stuff here
3188     }
3189
3190     mb_num= get_bits(&s->gb, mb_num_bits);
3191     if(mb_num>=s->mb_num){
3192         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3193         return -1;
3194     }
3195     if(s->pict_type == B_TYPE){
3196         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3197         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3198     }
3199
3200     s->mb_x= mb_num % s->mb_width;
3201     s->mb_y= mb_num / s->mb_width;
3202
3203     if(s->shape != BIN_ONLY_SHAPE){
3204         int qscale= get_bits(&s->gb, s->quant_precision);
3205         if(qscale)
3206             s->chroma_qscale=s->qscale= qscale;
3207     }
3208
3209     if(s->shape == RECT_SHAPE){
3210         header_extension= get_bits1(&s->gb);
3211     }
3212     if(header_extension){
3213         int time_increment;
3214         int time_incr=0;
3215
3216         while (get_bits1(&s->gb) != 0)
3217             time_incr++;
3218
3219         check_marker(&s->gb, "before time_increment in video packed header");
3220         time_increment= get_bits(&s->gb, s->time_increment_bits);
3221         check_marker(&s->gb, "before vop_coding_type in video packed header");
3222
3223         skip_bits(&s->gb, 2); /* vop coding type */
3224         //FIXME not rect stuff here
3225
3226         if(s->shape != BIN_ONLY_SHAPE){
3227             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3228 //FIXME don't just ignore everything
3229             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3230                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3231                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3232             }
3233
3234             //FIXME reduced res stuff here
3235
3236             if (s->pict_type != I_TYPE) {
3237                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3238                 if(f_code==0){
3239                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3240                 }
3241             }
3242             if (s->pict_type == B_TYPE) {
3243                 int b_code = get_bits(&s->gb, 3);
3244                 if(b_code==0){
3245                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3246                 }
3247             }
3248         }
3249     }
3250     //FIXME new-pred stuff
3251
3252 //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));
3253
3254     return 0;
3255 }
3256
3257 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3258 {
3259     int c_wrap, c_xy, l_wrap, l_xy;
3260
3261     l_wrap= s->b8_stride;
3262     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3263     c_wrap= s->mb_stride;
3264     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3265
3266 #if 0
3267     /* clean DC */
3268     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3269     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3270     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3271 #endif
3272
3273     /* clean AC */
3274     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3275     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3276     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3277
3278     /* clean MV */
3279     // we can't clear the MVs as they might be needed by a b frame
3280 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3281 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3282     s->last_mv[0][0][0]=
3283     s->last_mv[0][0][1]=
3284     s->last_mv[1][0][0]=
3285     s->last_mv[1][0][1]= 0;
3286 }
3287
3288 /**
3289  * decodes the group of blocks / video packet header.
3290  * @return <0 if no resync found
3291  */
3292 int ff_h263_resync(MpegEncContext *s){
3293     int left, ret;
3294
3295     if(s->codec_id==CODEC_ID_MPEG4){
3296         skip_bits1(&s->gb);
3297         align_get_bits(&s->gb);
3298     }
3299
3300     if(show_bits(&s->gb, 16)==0){
3301         if(s->codec_id==CODEC_ID_MPEG4)
3302             ret= mpeg4_decode_video_packet_header(s);
3303         else
3304             ret= h263_decode_gob_header(s);
3305         if(ret>=0)
3306             return 0;
3307     }
3308     //OK, it's not where it is supposed to be ...
3309     s->gb= s->last_resync_gb;
3310     align_get_bits(&s->gb);
3311     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3312
3313     for(;left>16+1+5+5; left-=8){
3314         if(show_bits(&s->gb, 16)==0){
3315             GetBitContext bak= s->gb;
3316
3317             if(s->codec_id==CODEC_ID_MPEG4)
3318                 ret= mpeg4_decode_video_packet_header(s);
3319             else
3320                 ret= h263_decode_gob_header(s);
3321             if(ret>=0)
3322                 return 0;
3323
3324             s->gb= bak;
3325         }
3326         skip_bits(&s->gb, 8);
3327     }
3328
3329     return -1;
3330 }
3331
3332 /**
3333  * gets the average motion vector for a GMC MB.
3334  * @param n either 0 for the x component or 1 for y
3335  * @returns the average MV for a GMC MB
3336  */
3337 static inline int get_amv(MpegEncContext *s, int n){
3338     int x, y, mb_v, sum, dx, dy, shift;
3339     int len = 1 << (s->f_code + 4);
3340     const int a= s->sprite_warping_accuracy;
3341
3342     if(s->workaround_bugs & FF_BUG_AMV)
3343         len >>= s->quarter_sample;
3344
3345     if(s->real_sprite_warping_points==1){
3346         if(s->divx_version==500 && s->divx_build==413)
3347             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3348         else
3349             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3350     }else{
3351         dx= s->sprite_delta[n][0];
3352         dy= s->sprite_delta[n][1];
3353         shift= s->sprite_shift[0];
3354         if(n) dy -= 1<<(shift + a + 1);
3355         else  dx -= 1<<(shift + a + 1);
3356         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3357
3358         sum=0;
3359         for(y=0; y<16; y++){
3360             int v;
3361
3362             v= mb_v + dy*y;
3363             //XXX FIXME optimize
3364             for(x=0; x<16; x++){
3365                 sum+= v>>shift;
3366                 v+= dx;
3367             }
3368         }
3369         sum= RSHIFT(sum, a+8-s->quarter_sample);
3370     }
3371
3372     if      (sum < -len) sum= -len;
3373     else if (sum >= len) sum= len-1;
3374
3375     return sum;
3376 }
3377
3378 /**
3379  * decodes first partition.
3380  * @return number of MBs decoded or <0 if an error occured
3381  */
3382 static int mpeg4_decode_partition_a(MpegEncContext *s){
3383     int mb_num;
3384     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3385
3386     /* decode first partition */
3387     mb_num=0;
3388     s->first_slice_line=1;
3389     for(; s->mb_y<s->mb_height; s->mb_y++){
3390         ff_init_block_index(s);
3391         for(; s->mb_x<s->mb_width; s->mb_x++){
3392             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3393             int cbpc;
3394             int dir=0;
3395
3396             mb_num++;
3397             ff_update_block_index(s);
3398             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3399                 s->first_slice_line=0;
3400
3401             if(s->pict_type==I_TYPE){
3402                 int i;
3403
3404                 do{
3405                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3406                         return mb_num-1;
3407                     }
3408
3409                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3410                     if (cbpc < 0){
3411                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3412                         return -1;
3413                     }
3414                 }while(cbpc == 8);
3415
3416                 s->cbp_table[xy]= cbpc & 3;
3417                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3418                 s->mb_intra = 1;
3419
3420                 if(cbpc & 4) {
3421                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3422                 }
3423                 s->current_picture.qscale_table[xy]= s->qscale;
3424
3425                 s->mbintra_table[xy]= 1;
3426                 for(i=0; i<6; i++){
3427                     int dc_pred_dir;
3428                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3429                     if(dc < 0){
3430                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3431                         return -1;
3432                     }
3433                     dir<<=1;
3434                     if(dc_pred_dir) dir|=1;
3435                 }
3436                 s->pred_dir_table[xy]= dir;
3437             }else{ /* P/S_TYPE */
3438                 int mx, my, pred_x, pred_y, bits;
3439                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3440                 const int stride= s->b8_stride*2;
3441
3442 try_again:
3443                 bits= show_bits(&s->gb, 17);
3444                 if(bits==MOTION_MARKER){
3445                     return mb_num-1;
3446                 }
3447                 skip_bits1(&s->gb);
3448                 if(bits&0x10000){
3449                     /* skip mb */
3450                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3451                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3452                         mx= get_amv(s, 0);
3453                         my= get_amv(s, 1);
3454                     }else{
3455                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3456                         mx=my=0;
3457                     }
3458                     mot_val[0       ]= mot_val[2       ]=
3459                     mot_val[0+stride]= mot_val[2+stride]= mx;
3460                     mot_val[1       ]= mot_val[3       ]=
3461                     mot_val[1+stride]= mot_val[3+stride]= my;
3462
3463                     if(s->mbintra_table[xy])
3464                         ff_clean_intra_table_entries(s);
3465                     continue;
3466                 }
3467
3468                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3469                 if (cbpc < 0){
3470                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3471                     return -1;
3472                 }
3473                 if(cbpc == 20)
3474                     goto try_again;
3475
3476                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3477
3478                 s->mb_intra = ((cbpc & 4) != 0);
3479
3480                 if(s->mb_intra){
3481                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3482                     s->mbintra_table[xy]= 1;
3483                     mot_val[0       ]= mot_val[2       ]=
3484                     mot_val[0+stride]= mot_val[2+stride]= 0;
3485                     mot_val[1       ]= mot_val[3       ]=
3486                     mot_val[1+stride]= mot_val[3+stride]= 0;
3487                 }else{
3488                     if(s->mbintra_table[xy])
3489                         ff_clean_intra_table_entries(s);
3490
3491                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3492                         s->mcsel= get_bits1(&s->gb);
3493                     else s->mcsel= 0;
3494
3495                     if ((cbpc & 16) == 0) {
3496                         /* 16x16 motion prediction */
3497
3498                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3499                         if(!s->mcsel){
3500                             mx = h263_decode_motion(s, pred_x, s->f_code);
3501                             if (mx >= 0xffff)
3502                                 return -1;
3503
3504                             my = h263_decode_motion(s, pred_y, s->f_code);
3505                             if (my >= 0xffff)
3506                                 return -1;
3507                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3508                         } else {
3509                             mx = get_amv(s, 0);
3510                             my = get_amv(s, 1);
3511                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3512                         }
3513
3514                         mot_val[0       ]= mot_val[2       ] =
3515                         mot_val[0+stride]= mot_val[2+stride]= mx;
3516                         mot_val[1       ]= mot_val[3       ]=
3517                         mot_val[1+stride]= mot_val[3+stride]= my;
3518                     } else {
3519                         int i;
3520                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3521                         for(i=0;i<4;i++) {
3522                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3523                             mx = h263_decode_motion(s, pred_x, s->f_code);
3524                             if (mx >= 0xffff)
3525                                 return -1;
3526
3527                             my = h263_decode_motion(s, pred_y, s->f_code);
3528                             if (my >= 0xffff)
3529                                 return -1;
3530                             mot_val[0] = mx;
3531                             mot_val[1] = my;
3532                         }
3533                     }
3534                 }
3535             }
3536         }
3537         s->mb_x= 0;
3538     }
3539
3540     return mb_num;
3541 }
3542
3543 /**
3544  * decode second partition.
3545  * @return <0 if an error occured
3546  */
3547 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3548     int mb_num=0;
3549     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3550
3551     s->mb_x= s->resync_mb_x;
3552     s->first_slice_line=1;
3553     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3554         ff_init_block_index(s);
3555         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3556             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3557
3558             mb_num++;
3559             ff_update_block_index(s);
3560             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3561                 s->first_slice_line=0;
3562
3563             if(s->pict_type==I_TYPE){
3564                 int ac_pred= get_bits1(&s->gb);
3565                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3566                 if(cbpy<0){
3567                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3568                     return -1;
3569                 }
3570
3571                 s->cbp_table[xy]|= cbpy<<2;
3572                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3573             }else{ /* P || S_TYPE */
3574                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3575                     int dir=0,i;
3576                     int ac_pred = get_bits1(&s->gb);
3577                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3578
3579                     if(cbpy<0){
3580                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3581                         return -1;
3582                     }
3583
3584                     if(s->cbp_table[xy] & 8) {
3585                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3586                     }
3587                     s->current_picture.qscale_table[xy]= s->qscale;
3588
3589                     for(i=0; i<6; i++){
3590                         int dc_pred_dir;
3591                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3592                         if(dc < 0){
3593                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3594                             return -1;
3595                         }
3596                         dir<<=1;
3597                         if(dc_pred_dir) dir|=1;
3598                     }
3599                     s->cbp_table[xy]&= 3; //remove dquant
3600                     s->cbp_table[xy]|= cbpy<<2;
3601                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3602                     s->pred_dir_table[xy]= dir;
3603                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3604                     s->current_picture.qscale_table[xy]= s->qscale;
3605                     s->cbp_table[xy]= 0;
3606                 }else{
3607                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3608
3609                     if(cbpy<0){
3610                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3611                         return -1;
3612                     }
3613
3614                     if(s->cbp_table[xy] & 8) {
3615                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3616                     }
3617                     s->current_picture.qscale_table[xy]= s->qscale;
3618
3619                     s->cbp_table[xy]&= 3; //remove dquant
3620                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3621                 }
3622             }
3623         }
3624         if(mb_num >= mb_count) return 0;
3625         s->mb_x= 0;
3626     }
3627     return 0;
3628 }
3629
3630 /**
3631  * decodes the first & second partition
3632  * @return <0 if error (and sets error type in the error_status_table)
3633  */
3634 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3635 {
3636     int mb_num;
3637     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3638     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3639
3640     mb_num= mpeg4_decode_partition_a(s);
3641     if(mb_num<0){
3642         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3643         return -1;
3644     }
3645
3646     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3647         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3648         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3649         return -1;
3650     }
3651
3652     s->mb_num_left= mb_num;
3653
3654     if(s->pict_type==I_TYPE){
3655         while(show_bits(&s->gb, 9) == 1)
3656             skip_bits(&s->gb, 9);
3657         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3658             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3659             return -1;
3660         }
3661     }else{
3662         while(show_bits(&s->gb, 10) == 1)
3663             skip_bits(&s->gb, 10);
3664         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3665             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3666             return -1;
3667         }
3668     }
3669     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3670
3671     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3672         if(s->pict_type==P_TYPE)
3673             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3674         return -1;
3675     }else{
3676         if(s->pict_type==P_TYPE)
3677             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3678     }
3679
3680     return 0;
3681 }
3682
3683 /**
3684  * decode partition C of one MB.
3685  * @return <0 if an error occured
3686  */
3687 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3688 {
3689     int cbp, mb_type;
3690     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3691
3692     mb_type= s->current_picture.mb_type[xy];
3693     cbp = s->cbp_table[xy];
3694
3695     s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3696
3697     if(s->current_picture.qscale_table[xy] != s->qscale){
3698         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3699     }
3700
3701     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3702         int i;
3703         for(i=0; i<4; i++){
3704             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3705             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3706         }
3707         s->mb_intra = IS_INTRA(mb_type);
3708
3709         if (IS_SKIP(mb_type)) {
3710             /* skip mb */
3711             for(i=0;i<6;i++)
3712                 s->block_last_index[i] = -1;
3713             s->mv_dir = MV_DIR_FORWARD;
3714             s->mv_type = MV_TYPE_16X16;
3715             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3716                 s->mcsel=1;
3717                 s->mb_skipped = 0;
3718             }else{
3719                 s->mcsel=0;
3720                 s->mb_skipped = 1;
3721             }
3722         }else if(s->mb_intra){
3723             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3724         }else if(!s->mb_intra){
3725 //            s->mcsel= 0; //FIXME do we need to init that
3726
3727             s->mv_dir = MV_DIR_FORWARD;
3728             if (IS_8X8(mb_type)) {
3729                 s->mv_type = MV_TYPE_8X8;
3730             } else {
3731                 s->mv_type = MV_TYPE_16X16;
3732             }
3733         }
3734     } else { /* I-Frame */
3735         s->mb_intra = 1;
3736         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3737     }
3738
3739     if (!IS_SKIP(mb_type)) {
3740         int i;
3741         s->dsp.clear_blocks(s->block[0]);
3742         /* decode each block */
3743         for (i = 0; i < 6; i++) {
3744             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3745                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3746                 return -1;
3747             }
3748             cbp+=cbp;
3749         }
3750     }
3751
3752     /* per-MB end of slice check */
3753
3754     if(--s->mb_num_left <= 0){
3755 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3756         if(mpeg4_is_resync(s))
3757             return SLICE_END;
3758         else
3759             return SLICE_NOEND;
3760     }else{
3761         if(mpeg4_is_resync(s)){
3762             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3763             if(s->cbp_table[xy+delta])
3764                 return SLICE_END;
3765         }
3766         return SLICE_OK;
3767     }
3768 }
3769
3770 /**
3771  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3772  */
3773 static void preview_obmc(MpegEncContext *s){
3774     GetBitContext gb= s->gb;
3775
3776     int cbpc, i, pred_x, pred_y, mx, my;
3777     int16_t *mot_val;
3778     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3779     const int stride= s->b8_stride*2;
3780
3781     for(i=0; i<4; i++)
3782         s->block_index[i]+= 2;
3783     for(i=4; i<6; i++)
3784         s->block_index[i]+= 1;
3785     s->mb_x++;
3786
3787     assert(s->pict_type == P_TYPE);
3788
3789     do{
3790         if (get_bits1(&s->gb)) {
3791             /* skip mb */
3792             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3793             mot_val[0       ]= mot_val[2       ]=
3794             mot_val[0+stride]= mot_val[2+stride]= 0;
3795             mot_val[1       ]= mot_val[3       ]=
3796             mot_val[1+stride]= mot_val[3+stride]= 0;
3797
3798             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3799             goto end;
3800         }
3801         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3802     }while(cbpc == 20);
3803
3804     if(cbpc & 4){
3805         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3806     }else{
3807         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3808         if (cbpc & 8) {
3809             if(s->modified_quant){
3810                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3811                 else                  skip_bits(&s->gb, 5);
3812             }else
3813                 skip_bits(&s->gb, 2);
3814         }
3815
3816         if ((cbpc & 16) == 0) {
3817                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3818                 /* 16x16 motion prediction */
3819                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3820                 if (s->umvplus)
3821                    mx = h263p_decode_umotion(s, pred_x);
3822                 else
3823                    mx = h263_decode_motion(s, pred_x, 1);
3824
3825                 if (s->umvplus)
3826                    my = h263p_decode_umotion(s, pred_y);
3827                 else
3828                    my = h263_decode_motion(s, pred_y, 1);
3829
3830                 mot_val[0       ]= mot_val[2       ]=
3831                 mot_val[0+stride]= mot_val[2+stride]= mx;
3832                 mot_val[1       ]= mot_val[3       ]=
3833                 mot_val[1+stride]= mot_val[3+stride]= my;
3834         } else {
3835             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3836             for(i=0;i<4;i++) {
3837                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3838                 if (s->umvplus)
3839                   mx = h263p_decode_umotion(s, pred_x);
3840                 else
3841                   mx = h263_decode_motion(s, pred_x, 1);
3842
3843                 if (s->umvplus)
3844                   my = h263p_decode_umotion(s, pred_y);
3845                 else
3846                   my = h263_decode_motion(s, pred_y, 1);
3847                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3848                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3849                 mot_val[0] = mx;
3850                 mot_val[1] = my;
3851             }
3852         }
3853     }
3854 end:
3855
3856     for(i=0; i<4; i++)
3857         s->block_index[i]-= 2;
3858     for(i=4; i<6; i++)
3859         s->block_index[i]-= 1;
3860     s->mb_x--;
3861
3862     s->gb= gb;
3863 }
3864
3865 static void h263_decode_dquant(MpegEncContext *s){
3866     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3867
3868     if(s->modified_quant){
3869         if(get_bits1(&s->gb))
3870             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3871         else
3872             s->qscale= get_bits(&s->gb, 5);
3873     }else
3874         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3875     ff_set_qscale(s, s->qscale);
3876 }
3877
3878 int ff_h263_decode_mb(MpegEncContext *s,
3879                       DCTELEM block[6][64])
3880 {
3881     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3882     int16_t *mot_val;
3883     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3884
3885     assert(!s->h263_pred);
3886
3887     if (s->pict_type == P_TYPE) {
3888         do{
3889             if (get_bits1(&s->gb)) {
3890                 /* skip mb */
3891                 s->mb_intra = 0;
3892                 for(i=0;i<6;i++)
3893                     s->block_last_index[i] = -1;
3894                 s->mv_dir = MV_DIR_FORWARD;
3895                 s->mv_type = MV_TYPE_16X16;
3896                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3897                 s->mv[0][0][0] = 0;
3898                 s->mv[0][0][1] = 0;
3899                 s->mb_skipped = !(s->obmc | s->loop_filter);
3900                 goto end;
3901             }
3902             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3903             //fprintf(stderr, "\tCBPC: %d", cbpc);
3904             if (cbpc < 0){
3905                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3906                 return -1;
3907             }
3908         }while(cbpc == 20);
3909
3910         s->dsp.clear_blocks(s->block[0]);
3911
3912         dquant = cbpc & 8;
3913         s->mb_intra = ((cbpc & 4) != 0);
3914         if (s->mb_intra) goto intra;
3915
3916         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3917
3918         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3919             cbpy ^= 0xF;
3920
3921         cbp = (cbpc & 3) | (cbpy << 2);
3922         if (dquant) {
3923             h263_decode_dquant(s);
3924         }
3925
3926         s->mv_dir = MV_DIR_FORWARD;
3927         if ((cbpc & 16) == 0) {
3928             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3929             /* 16x16 motion prediction */
3930             s->mv_type = MV_TYPE_16X16;
3931             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3932             if (s->umvplus)
3933                mx = h263p_decode_umotion(s, pred_x);
3934             else
3935                mx = h263_decode_motion(s, pred_x, 1);
3936
3937             if (mx >= 0xffff)
3938                 return -1;
3939
3940             if (s->umvplus)
3941                my = h263p_decode_umotion(s, pred_y);
3942             else
3943                my = h263_decode_motion(s, pred_y, 1);
3944
3945             if (my >= 0xffff)
3946                 return -1;
3947             s->mv[0][0][0] = mx;
3948             s->mv[0][0][1] = my;
3949
3950             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3951                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3952         } else {
3953             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3954             s->mv_type = MV_TYPE_8X8;
3955             for(i=0;i<4;i++) {
3956                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3957                 if (s->umvplus)
3958                   mx = h263p_decode_umotion(s, pred_x);
3959                 else
3960                   mx = h263_decode_motion(s, pred_x, 1);
3961                 if (mx >= 0xffff)
3962                     return -1;
3963
3964                 if (s->umvplus)
3965                   my = h263p_decode_umotion(s, pred_y);
3966                 else
3967                   my = h263_decode_motion(s, pred_y, 1);
3968                 if (my >= 0xffff)
3969                     return -1;
3970                 s->mv[0][i][0] = mx;
3971                 s->mv[0][i][1] = my;
3972                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3973                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3974                 mot_val[0] = mx;
3975                 mot_val[1] = my;
3976             }
3977         }
3978
3979         /* decode each block */
3980         for (i = 0; i < 6; i++) {
3981             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3982                 return -1;
3983             cbp+=cbp;
3984         }
3985
3986         if(s->obmc){
3987             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3988                 preview_obmc(s);
3989         }
3990     } else if(s->pict_type==B_TYPE) {
3991         int mb_type;
3992         const int stride= s->b8_stride;
3993         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3994         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3995 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3996
3997         //FIXME ugly
3998         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
3999         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4000         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4001         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4002
4003         do{
4004             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4005             if (mb_type < 0){
4006                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4007                 return -1;
4008             }
4009
4010             mb_type= h263_mb_type_b_map[ mb_type ];
4011         }while(!mb_type);
4012
4013         s->mb_intra = IS_INTRA(mb_type);
4014         if(HAS_CBP(mb_type)){
4015             s->dsp.clear_blocks(s->block[0]);
4016             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4017             if(s->mb_intra){
4018                 dquant = IS_QUANT(mb_type);
4019                 goto intra;
4020             }
4021
4022             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4023
4024             if (cbpy < 0){
4025                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4026                 return -1;
4027             }
4028
4029             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4030                 cbpy ^= 0xF;
4031
4032             cbp = (cbpc & 3) | (cbpy << 2);
4033         }else
4034             cbp=0;
4035
4036         assert(!s->mb_intra);
4037
4038         if(IS_QUANT(mb_type)){
4039             h263_decode_dquant(s);
4040         }
4041
4042         if(IS_DIRECT(mb_type)){
4043             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4044             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4045         }else{
4046             s->mv_dir = 0;
4047             s->mv_type= MV_TYPE_16X16;
4048 //FIXME UMV
4049
4050             if(USES_LIST(mb_type, 0)){
4051                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4052                 s->mv_dir = MV_DIR_FORWARD;
4053
4054                 mx = h263_decode_motion(s, mx, 1);
4055                 my = h263_decode_motion(s, my, 1);
4056
4057                 s->mv[0][0][0] = mx;
4058                 s->mv[0][0][1] = my;
4059                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4060                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4061             }
4062
4063             if(USES_LIST(mb_type, 1)){
4064                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4065                 s->mv_dir |= MV_DIR_BACKWARD;
4066
4067                 mx = h263_decode_motion(s, mx, 1);
4068                 my = h263_decode_motion(s, my, 1);
4069
4070                 s->mv[1][0][0] = mx;
4071                 s->mv[1][0][1] = my;
4072                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4073                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4074             }
4075         }
4076
4077         s->current_picture.mb_type[xy]= mb_type;
4078
4079         /* decode each block */
4080         for (i = 0; i < 6; i++) {
4081             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4082                 return -1;
4083             cbp+=cbp;
4084         }
4085     } else { /* I-Frame */
4086         do{
4087             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4088             if (cbpc < 0){
4089                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4090                 return -1;
4091             }
4092         }while(cbpc == 8);
4093
4094         s->dsp.clear_blocks(s->block[0]);
4095
4096         dquant = cbpc & 4;
4097         s->mb_intra = 1;
4098 intra:
4099         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4100         if (s->h263_aic) {
4101             s->ac_pred = get_bits1(&s->gb);
4102             if(s->ac_pred){
4103                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4104
4105                 s->h263_aic_dir = get_bits1(&s->gb);
4106             }
4107         }else
4108             s->ac_pred = 0;
4109
4110         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4111         if(cbpy<0){
4112             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4113             return -1;
4114         }
4115         cbp = (cbpc & 3) | (cbpy << 2);
4116         if (dquant) {
4117             h263_decode_dquant(s);
4118         }
4119
4120         /* decode each block */
4121         for (i = 0; i < 6; i++) {
4122             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4123                 return -1;
4124             cbp+=cbp;
4125         }
4126     }
4127 end:
4128
4129         /* per-MB end of slice check */
4130     {
4131         int v= show_bits(&s->gb, 16);
4132
4133         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4134             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4135         }
4136
4137         if(v==0)
4138             return SLICE_END;
4139     }
4140
4141     return SLICE_OK;
4142 }
4143
4144 int ff_mpeg4_decode_mb(MpegEncContext *s,
4145                       DCTELEM block[6][64])
4146 {
4147     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4148     int16_t *mot_val;
4149     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4150     const int xy= s->mb_x + s->mb_y * s->mb_stride;
4151
4152     assert(s->h263_pred);
4153
4154     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4155         do{
4156             if (get_bits1(&s->gb)) {
4157                 /* skip mb */
4158                 s->mb_intra = 0;
4159                 for(i=0;i<6;i++)
4160                     s->block_last_index[i] = -1;
4161                 s->mv_dir = MV_DIR_FORWARD;
4162                 s->mv_type = MV_TYPE_16X16;
4163                 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4164                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4165                     s->mcsel=1;
4166                     s->mv[0][0][0]= get_amv(s, 0);
4167                     s->mv[0][0][1]= get_amv(s, 1);
4168
4169                     s->mb_skipped = 0;
4170                 }else{
4171                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4172                     s->mcsel=0;
4173                     s->mv[0][0][0] = 0;
4174                     s->mv[0][0][1] = 0;
4175                     s->mb_skipped = 1;
4176                 }
4177                 goto end;
4178             }
4179             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4180             //fprintf(stderr, "\tCBPC: %d", cbpc);
4181             if (cbpc < 0){
4182                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4183                 return -1;
4184             }
4185         }while(cbpc == 20);
4186
4187         s->dsp.clear_blocks(s->block[0]);
4188         dquant = cbpc & 8;
4189         s->mb_intra = ((cbpc & 4) != 0);
4190         if (s->mb_intra) goto intra;
4191
4192         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4193             s->mcsel= get_bits1(&s->gb);
4194         else s->mcsel= 0;
4195         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4196
4197         cbp = (cbpc & 3) | (cbpy << 2);
4198         if (dquant) {
4199             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4200         }
4201         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4202             s->interlaced_dct= get_bits1(&s->gb);
4203
4204         s->mv_dir = MV_DIR_FORWARD;
4205         if ((cbpc & 16) == 0) {
4206             if(s->mcsel){
4207                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4208                 /* 16x16 global motion prediction */
4209                 s->mv_type = MV_TYPE_16X16;
4210                 mx= get_amv(s, 0);
4211                 my= get_amv(s, 1);
4212                 s->mv[0][0][0] = mx;
4213                 s->mv[0][0][1] = my;
4214             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4215                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4216                 /* 16x8 field motion prediction */
4217                 s->mv_type= MV_TYPE_FIELD;
4218
4219                 s->field_select[0][0]= get_bits1(&s->gb);
4220                 s->field_select[0][1]= get_bits1(&s->gb);
4221
4222                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4223
4224                 for(i=0; i<2; i++){
4225                     mx = h263_decode_motion(s, pred_x, s->f_code);
4226                     if (mx >= 0xffff)
4227                         return -1;
4228
4229                     my = h263_decode_motion(s, pred_y/2, s->f_code);
4230                     if (my >= 0xffff)
4231                         return -1;
4232
4233                     s->mv[0][i][0] = mx;
4234                     s->mv[0][i][1] = my;
4235                 }
4236             }else{
4237                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4238                 /* 16x16 motion prediction */
4239                 s->mv_type = MV_TYPE_16X16;
4240                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4241                 mx = h263_decode_motion(s, pred_x, s->f_code);
4242
4243                 if (mx >= 0xffff)
4244                     return -1;
4245
4246                 my = h263_decode_motion(s, pred_y, s->f_code);
4247
4248                 if (my >= 0xffff)
4249                     return -1;
4250                 s->mv[0][0][0] = mx;
4251                 s->mv[0][0][1] = my;
4252             }
4253         } else {
4254             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4255             s->mv_type = MV_TYPE_8X8;
4256             for(i=0;i<4;i++) {
4257                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4258                 mx = h263_decode_motion(s, pred_x, s->f_code);
4259                 if (mx >= 0xffff)
4260                     return -1;
4261
4262                 my = h263_decode_motion(s, pred_y, s->f_code);
4263                 if (my >= 0xffff)
4264                     return -1;
4265                 s->mv[0][i][0] = mx;
4266                 s->mv[0][i][1] = my;
4267                 mot_val[0] = mx;
4268                 mot_val[1] = my;
4269             }
4270         }
4271     } else if(s->pict_type==B_TYPE) {
4272         int modb1; // first bit of modb
4273         int modb2; // second bit of modb
4274         int mb_type;
4275
4276         s->mb_intra = 0; //B-frames never contain intra blocks
4277         s->mcsel=0;      //     ...               true gmc blocks
4278
4279         if(s->mb_x==0){
4280             for(i=0; i<2; i++){
4281                 s->last_mv[i][0][0]=
4282                 s->last_mv[i][0][1]=
4283                 s->last_mv[i][1][0]=
4284                 s->last_mv[i][1][1]= 0;
4285             }
4286         }
4287
4288         /* if we skipped it in the future P Frame than skip it now too */
4289         s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4290
4291         if(s->mb_skipped){
4292                 /* skip mb */
4293             for(i=0;i<6;i++)
4294                 s->block_last_index[i] = -1;
4295
4296             s->mv_dir = MV_DIR_FORWARD;
4297             s->mv_type = MV_TYPE_16X16;
4298             s->mv[0][0][0] = 0;
4299             s->mv[0][0][1] = 0;
4300             s->mv[1][0][0] = 0;
4301             s->mv[1][0][1] = 0;
4302             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4303             goto end;
4304         }
4305
4306         modb1= get_bits1(&s->gb);
4307         if(modb1){
4308             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4309             cbp=0;
4310         }else{
4311             modb2= get_bits1(&s->gb);
4312             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4313             if(mb_type<0){
4314                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4315                 return -1;
4316             }
4317             mb_type= mb_type_b_map[ mb_type ];
4318             if(modb2) cbp= 0;
4319             else{
4320                 s->dsp.clear_blocks(s->block[0]);
4321                 cbp= get_bits(&s->gb, 6);
4322             }
4323
4324             if ((!IS_DIRECT(mb_type)) && cbp) {
4325                 if(get_bits1(&s->gb)){
4326                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4327                 }
4328             }
4329
4330             if(!s->progressive_sequence){
4331                 if(cbp)
4332                     s->interlaced_dct= get_bits1(&s->gb);
4333
4334                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4335                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4336                     mb_type &= ~MB_TYPE_16x16;
4337
4338                     if(USES_LIST(mb_type, 0)){
4339                         s->field_select[0][0]= get_bits1(&s->gb);
4340                         s->field_select[0][1]= get_bits1(&s->gb);
4341                     }
4342                     if(USES_LIST(mb_type, 1)){
4343                         s->field_select[1][0]= get_bits1(&s->gb);
4344                         s->field_select[1][1]= get_bits1(&s->gb);
4345                     }
4346                 }
4347             }
4348
4349             s->mv_dir = 0;
4350             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4351                 s->mv_type= MV_TYPE_16X16;
4352
4353                 if(USES_LIST(mb_type, 0)){
4354                     s->mv_dir = MV_DIR_FORWARD;
4355
4356                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4357                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4358                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4359                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4360                 }
4361
4362                 if(USES_LIST(mb_type, 1)){
4363                     s->mv_dir |= MV_DIR_BACKWARD;
4364
4365                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4366                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4367                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4368                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4369                 }
4370             }else if(!IS_DIRECT(mb_type)){
4371                 s->mv_type= MV_TYPE_FIELD;
4372
4373                 if(USES_LIST(mb_type, 0)){
4374                     s->mv_dir = MV_DIR_FORWARD;
4375
4376                     for(i=0; i<2; i++){
4377                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4378                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4379                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4380                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4381                     }
4382                 }
4383
4384                 if(USES_LIST(mb_type, 1)){
4385                     s->mv_dir |= MV_DIR_BACKWARD;
4386
4387                     for(i=0; i<2; i++){
4388                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4389                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4390                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4391                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4392                     }
4393                 }
4394             }
4395         }
4396
4397         if(IS_DIRECT(mb_type)){
4398             if(IS_SKIP(mb_type))
4399                 mx=my=0;
4400             else{
4401                 mx = h263_decode_motion(s, 0, 1);
4402                 my = h263_decode_motion(s, 0, 1);
4403             }
4404
4405             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4406             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4407         }
4408         s->current_picture.mb_type[xy]= mb_type;
4409     } else { /* I-Frame */
4410         do{
4411             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4412             if (cbpc < 0){
4413                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4414                 return -1;
4415             }
4416         }while(cbpc == 8);
4417
4418         dquant = cbpc & 4;
4419         s->mb_intra = 1;
4420 intra:
4421         s->ac_pred = get_bits1(&s->gb);
4422         if(s->ac_pred)
4423             s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4424         else
4425             s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4426
4427         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4428         if(cbpy<0){
4429             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4430             return -1;
4431         }
4432         cbp = (cbpc & 3) | (cbpy << 2);
4433
4434         s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4435
4436         if (dquant) {
4437             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4438         }
4439
4440         if(!s->progressive_sequence)
4441             s->interlaced_dct= get_bits1(&s->gb);
4442
4443         s->dsp.clear_blocks(s->block[0]);
4444         /* decode each block */
4445         for (i = 0; i < 6; i++) {
4446             if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4447                 return -1;
4448             cbp+=cbp;
4449         }
4450         goto end;
4451     }
4452
4453     /* decode each block */
4454     for (i = 0; i < 6; i++) {
4455         if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4456             return -1;
4457         cbp+=cbp;
4458     }
4459 end:
4460
4461         /* per-MB end of slice check */
4462     if(s->codec_id==CODEC_ID_MPEG4){
4463         if(mpeg4_is_resync(s)){
4464             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4465             if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4466                 return SLICE_OK;
4467             return SLICE_END;
4468         }
4469     }
4470
4471     return SLICE_OK;
4472 }
4473
4474 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4475 {
4476     int code, val, sign, shift, l;
4477     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4478
4479     if (code == 0)
4480         return pred;
4481     if (code < 0)
4482         return 0xffff;
4483
4484     sign = get_bits1(&s->gb);
4485     shift = f_code - 1;
4486     val = code;
4487     if (shift) {
4488         val = (val - 1) << shift;
4489         val |= get_bits(&s->gb, shift);
4490         val++;
4491     }
4492     if (sign)
4493         val = -val;
4494     val += pred;
4495
4496     /* modulo decoding */
4497     if (!s->h263_long_vectors) {
4498         l = INT_BIT - 5 - f_code;
4499         val = (val<<l)>>l;
4500     } else {
4501         /* horrible h263 long vector mode */
4502         if (pred < -31 && val < -63)
4503             val += 64;
4504         if (pred > 32 && val > 63)
4505             val -= 64;
4506
4507     }
4508     return val;
4509 }
4510
4511 /* Decodes RVLC of H.263+ UMV */
4512 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4513 {
4514    int code = 0, sign;
4515
4516    if (get_bits1(&s->gb)) /* Motion difference = 0 */
4517       return pred;
4518
4519    code = 2 + get_bits1(&s->gb);
4520
4521    while (get_bits1(&s->gb))
4522    {
4523       code <<= 1;
4524       code += get_bits1(&s->gb);
4525    }
4526    sign = code & 1;
4527    code >>= 1;
4528
4529    code = (sign) ? (pred - code) : (pred + code);
4530 #ifdef DEBUG
4531    av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4532 #endif
4533    return code;
4534
4535 }
4536
4537 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4538                              int n, int coded)
4539 {
4540     int code, level, i, j, last, run;
4541     RLTable *rl = &rl_inter;
4542     const uint8_t *scan_table;
4543     GetBitContext gb= s->gb;
4544
4545     scan_table = s->intra_scantable.permutated;
4546     if (s->h263_aic && s->mb_intra) {
4547         rl = &rl_intra_aic;
4548         i = 0;
4549         if (s->ac_pred) {
4550             if (s->h263_aic_dir)
4551                 scan_table = s->intra_v_scantable.permutated; /* left */
4552             else
4553                 scan_table = s->intra_h_scantable.permutated; /* top */
4554         }
4555     } else if (s->mb_intra) {
4556         /* DC coef */
4557         if(s->codec_id == CODEC_ID_RV10){
4558 #ifdef CONFIG_RV10_DECODER
4559           if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4560             int component, diff;
4561             component = (n <= 3 ? 0 : n - 4 + 1);
4562             level = s->last_dc[component];
4563             if (s->rv10_first_dc_coded[component]) {
4564                 diff = rv_decode_dc(s, n);
4565                 if (diff == 0xffff)
4566                     return -1;
4567                 level += diff;
4568                 level = level & 0xff; /* handle wrap round */
4569                 s->last_dc[component] = level;
4570             } else {
4571                 s->rv10_first_dc_coded[component] = 1;
4572             }
4573           } else {
4574                 level = get_bits(&s->gb, 8);
4575                 if (level == 255)
4576                     level = 128;
4577           }
4578 #endif
4579         }else{
4580             level = get_bits(&s->gb, 8);
4581             if((level&0x7F) == 0){
4582                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4583                 if(s->error_resilience >= FF_ER_COMPLIANT)
4584                     return -1;
4585             }
4586             if (level == 255)
4587                 level = 128;
4588         }
4589         block[0] = level;
4590         i = 1;
4591     } else {
4592         i = 0;
4593     }
4594     if (!coded) {
4595         if (s->mb_intra && s->h263_aic)
4596             goto not_coded;
4597         s->block_last_index[n] = i - 1;
4598         return 0;
4599     }
4600 retry:
4601     for(;;) {
4602         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4603         if (code < 0){
4604             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4605             return -1;
4606         }
4607         if (code == rl->n) {
4608             /* escape */
4609             if (s->h263_flv > 1) {
4610                 int is11 = get_bits1(&s->gb);
4611                 last = get_bits1(&s->gb);
4612                 run = get_bits(&s->gb, 6);
4613                 if(is11){
4614                     level = get_sbits(&s->gb, 11);
4615                 } else {
4616                     level = get_sbits(&s->gb, 7);
4617                 }
4618             } else {
4619                 last = get_bits1(&s->gb);
4620                 run = get_bits(&s->gb, 6);
4621                 level = (int8_t)get_bits(&s->gb, 8);
4622                 if(level == -128){
4623                     if (s->codec_id == CODEC_ID_RV10) {
4624                         /* XXX: should patch encoder too */
4625                         level = get_sbits(&s->gb, 12);
4626                     }else{
4627                         level = get_bits(&s->gb, 5);
4628                         level |= get_sbits(&s->gb, 6)<<5;
4629                     }
4630                 }
4631             }
4632         } else {
4633             run = rl->table_run[code];
4634             level = rl->table_level[code];
4635             last = code >= rl->last;
4636             if (get_bits1(&s->gb))
4637                 level = -level;
4638         }
4639         i += run;
4640         if (i >= 64){
4641             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4642                 //Looks like a hack but no, it's the way it is supposed to work ...
4643                 rl = &rl_intra_aic;
4644                 i = 0;
4645                 s->gb= gb;
4646                 memset(block, 0, sizeof(DCTELEM)*64);
4647                 goto retry;
4648             }
4649             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4650             return -1;
4651         }
4652         j = scan_table[i];
4653         block[j] = level;
4654         if (last)
4655             break;
4656         i++;
4657     }
4658 not_coded:
4659     if (s->mb_intra && s->h263_aic) {
4660         h263_pred_acdc(s, block, n);
4661         i = 63;
4662     }
4663     s->block_last_index[n] = i;
4664     return 0;
4665 }
4666
4667 /**
4668  * decodes the dc value.
4669  * @param n block index (0-3 are luma, 4-5 are chroma)
4670  * @param dir_ptr the prediction direction will be stored here
4671  * @return the quantized dc
4672  */
4673 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4674 {
4675     int level, code;
4676
4677     if (n < 4)
4678         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4679     else
4680         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4681     if (code < 0 || code > 9 /* && s->nbit<9 */){
4682         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4683         return -1;
4684     }
4685     if (code == 0) {
4686         level = 0;
4687     } else {
4688         if(IS_3IV1){
4689             if(code==1)
4690                 level= 2*get_bits1(&s->gb)-1;
4691             else{
4692                 if(get_bits1(&s->gb))
4693                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
4694                 else
4695                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4696             }
4697         }else{
4698             level = get_xbits(&s->gb, code);
4699         }
4700
4701         if (code > 8){
4702             if(get_bits1(&s->gb)==0){ /* marker */
4703                 if(s->error_resilience>=2){
4704                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4705                     return -1;
4706                 }
4707             }
4708         }
4709     }
4710
4711     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4712 }
4713
4714 /**
4715  * decodes a block.
4716  * @return <0 if an error occured
4717  */
4718 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4719                               int n, int coded, int intra, int rvlc)
4720 {
4721     int level, i, last, run;
4722     int dc_pred_dir;
4723     RLTable * rl;
4724     RL_VLC_ELEM * rl_vlc;
4725     const uint8_t * scan_table;
4726     int qmul, qadd;
4727
4728     //Note intra & rvlc should be optimized away if this is inlined
4729
4730     if(intra) {
4731       if(s->use_intra_dc_vlc){
4732         /* DC coef */
4733         if(s->partitioned_frame){
4734             level = s->dc_val[0][ s->block_index[n] ];
4735             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4736             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4737             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4738         }else{
4739             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4740             if (level < 0)
4741                 return -1;
4742         }
4743         block[0] = level;
4744         i = 0;
4745       }else{
4746             i = -1;
4747             ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4748       }
4749         if (!coded)
4750             goto not_coded;
4751
4752         if(rvlc){
4753             rl = &rvlc_rl_intra;
4754             rl_vlc = rvlc_rl_intra.rl_vlc[0];
4755         }else{
4756             rl = &rl_intra;
4757             rl_vlc = rl_intra.rl_vlc[0];
4758         }
4759         if (s->ac_pred) {
4760             if (dc_pred_dir == 0)
4761                 scan_table = s->intra_v_scantable.permutated; /* left */
4762             else
4763                 scan_table = s->intra_h_scantable.permutated; /* top */
4764         } else {
4765             scan_table = s->intra_scantable.permutated;
4766         }
4767         qmul=1;
4768         qadd=0;
4769     } else {
4770         i = -1;
4771         if (!coded) {
4772             s->block_last_index[n] = i;
4773             return 0;
4774         }
4775         if(rvlc) rl = &rvlc_rl_inter;
4776         else     rl = &rl_inter;
4777
4778         scan_table = s->intra_scantable.permutated;
4779
4780         if(s->mpeg_quant){
4781             qmul=1;
4782             qadd=0;
4783             if(rvlc){
4784                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4785             }else{
4786                 rl_vlc = rl_inter.rl_vlc[0];
4787             }
4788         }else{
4789             qmul = s->qscale << 1;
4790             qadd = (s->qscale - 1) | 1;
4791             if(rvlc){
4792                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4793             }else{
4794                 rl_vlc = rl_inter.rl_vlc[s->qscale];
4795             }
4796         }
4797     }
4798   {
4799     OPEN_READER(re, &s->gb);
4800     for(;;) {
4801         UPDATE_CACHE(re, &s->gb);
4802         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4803         if (level==0) {
4804           /* escape */
4805           if(rvlc){
4806                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4807                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4808                     return -1;
4809                 }; SKIP_CACHE(re, &s->gb, 1);
4810
4811                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4812                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4813                 SKIP_COUNTER(re, &s->gb, 1+1+6);
4814                 UPDATE_CACHE(re, &s->gb);
4815
4816                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4817                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4818                     return -1;
4819                 }; SKIP_CACHE(re, &s->gb, 1);
4820
4821                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4822
4823                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4824                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4825                     return -1;
4826                 }; SKIP_CACHE(re, &s->gb, 5);
4827
4828                 level=  level * qmul + qadd;
4829                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4830                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4831
4832                 i+= run + 1;
4833                 if(last) i+=192;
4834           }else{
4835             int cache;
4836             cache= GET_CACHE(re, &s->gb);
4837
4838             if(IS_3IV1)
4839                 cache ^= 0xC0000000;
4840
4841             if (cache&0x80000000) {
4842                 if (cache&0x40000000) {
4843                     /* third escape */
4844                     SKIP_CACHE(re, &s->gb, 2);
4845                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4846                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4847                     SKIP_COUNTER(re, &s->gb, 2+1+6);
4848                     UPDATE_CACHE(re, &s->gb);
4849
4850                     if(IS_3IV1){
4851                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4852                     }else{
4853                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4854                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4855                             return -1;
4856                         }; SKIP_CACHE(re, &s->gb, 1);
4857
4858                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4859
4860                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4861                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4862                             return -1;
4863                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
4864
4865                         SKIP_COUNTER(re, &s->gb, 1+12+1);
4866                     }
4867
4868 #if 0
4869                     if(s->error_resilience >= FF_ER_COMPLIANT){
4870                         const int abs_level= FFABS(level);
4871                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4872                             const int run1= run - rl->max_run[last][abs_level] - 1;
4873                             if(abs_level <= rl->max_level[last][run]){
4874                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4875                                 return -1;
4876                             }
4877                             if(s->error_resilience > FF_ER_COMPLIANT){
4878                                 if(abs_level <= rl->max_level[last][run]*2){
4879                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4880                                     return -1;
4881                                 }
4882                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4883                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4884                                     return -1;
4885                                 }
4886                             }
4887                         }
4888                     }
4889 #endif
4890                     if (level>0) level= level * qmul + qadd;
4891                     else         level= level * qmul - qadd;
4892
4893                     if((unsigned)(level + 2048) > 4095){
4894                         if(s->error_resilience > FF_ER_COMPLIANT){
4895                             if(level > 2560 || level<-2560){
4896                                 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4897                                 return -1;
4898                             }
4899                         }
4900                         level= level<0 ? -2048 : 2047;
4901                     }
4902
4903                     i+= run + 1;
4904                     if(last) i+=192;
4905                 } else {
4906                     /* second escape */
4907 #if MIN_CACHE_BITS < 20
4908                     LAST_SKIP_BITS(re, &s->gb, 2);
4909                     UPDATE_CACHE(re, &s->gb);
4910 #else
4911                     SKIP_BITS(re, &s->gb, 2);
4912 #endif
4913                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4914                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4915                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4916                     LAST_SKIP_BITS(re, &s->gb, 1);
4917                 }
4918             } else {
4919                 /* first escape */
4920 #if MIN_CACHE_BITS < 19
4921                 LAST_SKIP_BITS(re, &s->gb, 1);
4922                 UPDATE_CACHE(re, &s->gb);
4923 #else
4924                 SKIP_BITS(re, &s->gb, 1);
4925 #endif
4926                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4927                 i+= run;
4928                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4929                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4930                 LAST_SKIP_BITS(re, &s->gb, 1);
4931             }
4932           }
4933         } else {
4934             i+= run;
4935             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4936             LAST_SKIP_BITS(re, &s->gb, 1);
4937         }
4938         if (i > 62){
4939             i-= 192;
4940             if(i&(~63)){
4941                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4942                 return -1;
4943             }
4944
4945             block[scan_table[i]] = level;
4946             break;
4947         }
4948
4949         block[scan_table[i]] = level;
4950     }
4951     CLOSE_READER(re, &s->gb);
4952   }
4953  not_coded:
4954     if (intra) {
4955         if(!s->use_intra_dc_vlc){
4956             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
4957
4958             i -= i>>31; //if(i == -1) i=0;
4959         }
4960
4961         mpeg4_pred_ac(s, block, n, dc_pred_dir);
4962         if (s->ac_pred) {
4963             i = 63; /* XXX: not optimal */
4964         }
4965     }
4966     s->block_last_index[n] = i;
4967     return 0;
4968 }
4969
4970 /* most is hardcoded. should extend to handle all h263 streams */
4971 int h263_decode_picture_header(MpegEncContext *s)
4972 {
4973     int format, width, height, i;
4974     uint32_t startcode;
4975
4976     align_get_bits(&s->gb);
4977
4978     startcode= get_bits(&s->gb, 22-8);
4979
4980     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4981         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4982
4983         if(startcode == 0x20)
4984             break;
4985     }
4986
4987     if (startcode != 0x20) {
4988         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
4989         return -1;
4990     }
4991     /* temporal reference */
4992     i = get_bits(&s->gb, 8); /* picture timestamp */
4993     if( (s->picture_number&~0xFF)+i < s->picture_number)
4994         i+= 256;
4995     s->current_picture_ptr->pts=
4996     s->picture_number= (s->picture_number&~0xFF) + i;
4997
4998     /* PTYPE starts here */
4999     if (get_bits1(&s->gb) != 1) {
5000         /* marker */
5001         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5002         return -1;
5003     }
5004     if (get_bits1(&s->gb) != 0) {
5005         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5006         return -1;      /* h263 id */
5007     }
5008     skip_bits1(&s->gb);         /* split screen off */
5009     skip_bits1(&s->gb);         /* camera  off */
5010     skip_bits1(&s->gb);         /* freeze picture release off */
5011
5012     format = get_bits(&s->gb, 3);
5013     /*
5014         0    forbidden
5015         1    sub-QCIF
5016         10   QCIF
5017         7       extended PTYPE (PLUSPTYPE)
5018     */
5019
5020     if (format != 7 && format != 6) {
5021         s->h263_plus = 0;
5022         /* H.263v1 */
5023         width = h263_format[format][0];
5024         height = h263_format[format][1];
5025         if (!width)
5026             return -1;
5027
5028         s->pict_type = I_TYPE + get_bits1(&s->gb);
5029
5030         s->h263_long_vectors = get_bits1(&s->gb);
5031
5032         if (get_bits1(&s->gb) != 0) {
5033             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5034             return -1; /* SAC: off */
5035         }
5036         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5037         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5038
5039         if (get_bits1(&s->gb) != 0) {
5040             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5041             return -1; /* not PB frame */
5042         }
5043         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5044         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5045
5046         s->width = width;
5047         s->height = height;
5048         s->avctx->sample_aspect_ratio= (AVRational){12,11};
5049         s->avctx->time_base= (AVRational){1001, 30000};
5050     } else {
5051         int ufep;
5052
5053         /* H.263v2 */
5054         s->h263_plus = 1;
5055         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5056
5057         /* ufep other than 0 and 1 are reserved */
5058         if (ufep == 1) {
5059             /* OPPTYPE */
5060             format = get_bits(&s->gb, 3);
5061             dprintf(s->avctx, "ufep=1, format: %d\n", format);
5062             s->custom_pcf= get_bits1(&s->gb);
5063             s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5064             if (get_bits1(&s->gb) != 0) {
5065                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5066             }
5067             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5068             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5069             s->loop_filter= get_bits1(&s->gb);
5070             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5071
5072             s->h263_slice_structured= get_bits1(&s->gb);
5073             if (get_bits1(&s->gb) != 0) {
5074                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5075             }
5076             if (get_bits1(&s->gb) != 0) {
5077                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5078             }
5079             s->alt_inter_vlc= get_bits1(&s->gb);
5080             s->modified_quant= get_bits1(&s->gb);
5081             if(s->modified_quant)
5082                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5083
5084             skip_bits(&s->gb, 1); /* Prevent start code emulation */
5085
5086             skip_bits(&s->gb, 3); /* Reserved */
5087         } else if (ufep != 0) {
5088             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5089             return -1;
5090         }
5091
5092         /* MPPTYPE */
5093         s->pict_type = get_bits(&s->gb, 3);
5094         switch(s->pict_type){
5095         case 0: s->pict_type= I_TYPE;break;
5096         case 1: s->pict_type= P_TYPE;break;
5097         case 3: s->pict_type= B_TYPE;break;
5098         case 7: s->pict_type= I_TYPE;break; //ZYGO
5099         default:
5100             return -1;
5101         }
5102         skip_bits(&s->gb, 2);
5103         s->no_rounding = get_bits1(&s->gb);
5104         skip_bits(&s->gb, 4);
5105
5106         /* Get the picture dimensions */
5107         if (ufep) {
5108             if (format == 6) {
5109                 /* Custom Picture Format (CPFMT) */
5110                 s->aspect_ratio_info = get_bits(&s->gb, 4);
5111                 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
5112                 /* aspect ratios:
5113                 0 - forbidden
5114                 1 - 1:1
5115                 2 - 12:11 (CIF 4:3)
5116                 3 - 10:11 (525-type 4:3)
5117                 4 - 16:11 (CIF 16:9)
5118                 5 - 40:33 (525-type 16:9)
5119                 6-14 - reserved
5120                 */
5121                 width = (get_bits(&s->gb, 9) + 1) * 4;
5122                 skip_bits1(&s->gb);
5123                 height = get_bits(&s->gb, 9) * 4;
5124                 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
5125                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5126                     /* aspected dimensions */
5127                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5128                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5129                 }else{
5130                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5131                 }
5132             } else {
5133                 width = h263_format[format][0];
5134                 height = h263_format[format][1];
5135                 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5136             }
5137             if ((width == 0) || (height == 0))
5138                 return -1;
5139             s->width = width;
5140             s->height = height;
5141
5142             if(s->custom_pcf){
5143                 int gcd;
5144                 s->avctx->time_base.den= 1800000;
5145                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5146                 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5147                 if(s->avctx->time_base.num == 0){
5148                     av_log(s, AV_LOG_ERROR, "zero framerate\n");
5149                     return -1;
5150                 }
5151                 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5152                 s->avctx->time_base.den /= gcd;
5153                 s->avctx->time_base.num /= gcd;
5154 //                av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5155             }else{
5156                 s->avctx->time_base= (AVRational){1001, 30000};
5157             }
5158         }
5159
5160         if(s->custom_pcf){
5161             skip_bits(&s->gb, 2); //extended Temporal reference
5162         }
5163
5164         if (ufep) {
5165             if (s->umvplus) {
5166                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5167                     skip_bits1(&s->gb);
5168             }
5169             if(s->h263_slice_structured){
5170                 if (get_bits1(&s->gb) != 0) {
5171                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5172                 }
5173                 if (get_bits1(&s->gb) != 0) {
5174                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5175                 }
5176             }
5177         }
5178
5179         s->qscale = get_bits(&s->gb, 5);
5180     }
5181
5182     s->mb_width = (s->width  + 15) / 16;
5183     s->mb_height = (s->height  + 15) / 16;
5184     s->mb_num = s->mb_width * s->mb_height;
5185
5186     /* PEI */
5187     while (get_bits1(&s->gb) != 0) {
5188         skip_bits(&s->gb, 8);
5189     }
5190
5191     if(s->h263_slice_structured){
5192         if (get_bits1(&s->gb) != 1) {
5193             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5194             return -1;
5195         }
5196
5197         ff_h263_decode_mba(s);
5198
5199         if (get_bits1(&s->gb) != 1) {
5200             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5201             return -1;
5202         }
5203     }
5204     s->f_code = 1;
5205
5206     if(s->h263_aic){
5207          s->y_dc_scale_table=
5208          s->c_dc_scale_table= ff_aic_dc_scale_table;
5209     }else{
5210         s->y_dc_scale_table=
5211         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5212     }
5213
5214      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5215          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",
5216          s->qscale, av_get_pict_type_char(s->pict_type),
5217          s->gb.size_in_bits, 1-s->no_rounding,
5218          s->obmc ? " AP" : "",
5219          s->umvplus ? " UMV" : "",
5220          s->h263_long_vectors ? " LONG" : "",
5221          s->h263_plus ? " +" : "",
5222          s->h263_aic ? " AIC" : "",
5223          s->alt_inter_vlc ? " AIV" : "",
5224          s->modified_quant ? " MQ" : "",
5225          s->loop_filter ? " LOOP" : "",
5226          s->h263_slice_structured ? " SS" : "",
5227          s->avctx->time_base.den, s->avctx->time_base.num
5228          );
5229      }
5230 #if 1
5231     if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
5232         int i,j;
5233         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5234         av_log(s->avctx, AV_LOG_DEBUG, "\n");
5235         for(i=0; i<13; i++){
5236             for(j=0; j<3; j++){
5237                 int v= get_bits(&s->gb, 8);
5238                 v |= get_sbits(&s->gb, 8)<<8;
5239                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5240             }
5241             av_log(s->avctx, AV_LOG_DEBUG, "\n");
5242         }
5243         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5244     }
5245 #endif
5246
5247     return 0;
5248 }
5249
5250 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5251 {
5252     int i;
5253     int a= 2<<s->sprite_warping_accuracy;
5254     int rho= 3-s->sprite_warping_accuracy;
5255     int r=16/a;
5256     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5257     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5258     int sprite_ref[4][2];
5259     int virtual_ref[2][2];
5260     int w2, h2, w3, h3;
5261     int alpha=0, beta=0;
5262     int w= s->width;
5263     int h= s->height;
5264     int min_ab;
5265
5266     for(i=0; i<s->num_sprite_warping_points; i++){
5267         int length;
5268         int x=0, y=0;
5269
5270         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5271         if(length){
5272             x= get_xbits(gb, length);
5273         }
5274         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5275
5276         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5277         if(length){
5278             y=get_xbits(gb, length);
5279         }
5280         skip_bits1(gb); /* marker bit */
5281 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5282         d[i][0]= x;
5283         d[i][1]= y;
5284     }
5285
5286     while((1<<alpha)<w) alpha++;
5287     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5288     w2= 1<<alpha;
5289     h2= 1<<beta;
5290
5291 // Note, the 4th point isn't used for GMC
5292     if(s->divx_version==500 && s->divx_build==413){
5293         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5294         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5295         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5296         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5297         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5298         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5299     } else {
5300         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5301         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5302         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5303         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5304         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5305         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5306     }
5307 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5308     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5309
5310 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5311 // perhaps it should be reordered to be more readable ...
5312 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5313 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5314     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5315         + 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);
5316     virtual_ref[0][1]= 16*vop_ref[0][1]
5317         + 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);
5318     virtual_ref[1][0]= 16*vop_ref[0][0]
5319         + 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);
5320     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5321         + 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);
5322
5323     switch(s->num_sprite_warping_points)
5324     {
5325         case 0:
5326             s->sprite_offset[0][0]= 0;
5327             s->sprite_offset[0][1]= 0;
5328             s->sprite_offset[1][0]= 0;
5329             s->sprite_offset[1][1]= 0;
5330             s->sprite_delta[0][0]= a;
5331             s->sprite_delta[0][1]= 0;
5332             s->sprite_delta[1][0]= 0;
5333             s->sprite_delta[1][1]= a;
5334             s->sprite_shift[0]= 0;
5335             s->sprite_shift[1]= 0;
5336             break;
5337         case 1: //GMC only
5338             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5339             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5340             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5341             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5342             s->sprite_delta[0][0]= a;
5343             s->sprite_delta[0][1]= 0;
5344             s->sprite_delta[1][0]= 0;
5345             s->sprite_delta[1][1]= a;
5346             s->sprite_shift[0]= 0;
5347             s->sprite_shift[1]= 0;
5348             break;
5349         case 2:
5350             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5351                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5352                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5353                                                   + (1<<(alpha+rho-1));
5354             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5355                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5356                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5357                                                   + (1<<(alpha+rho-1));
5358             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5359                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5360                                      +2*w2*r*sprite_ref[0][0]
5361                                      - 16*w2
5362                                      + (1<<(alpha+rho+1)));
5363             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5364                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5365                                      +2*w2*r*sprite_ref[0][1]
5366                                      - 16*w2
5367                                      + (1<<(alpha+rho+1)));
5368             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5369             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5370             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5371             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5372
5373             s->sprite_shift[0]= alpha+rho;
5374             s->sprite_shift[1]= alpha+rho+2;
5375             break;
5376         case 3:
5377             min_ab= FFMIN(alpha, beta);
5378             w3= w2>>min_ab;
5379             h3= h2>>min_ab;
5380             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5381                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5382                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5383                                    + (1<<(alpha+beta+rho-min_ab-1));
5384             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5385                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5386                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5387                                    + (1<<(alpha+beta+rho-min_ab-1));
5388             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5389                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5390                                    + 2*w2*h3*r*sprite_ref[0][0]
5391                                    - 16*w2*h3
5392                                    + (1<<(alpha+beta+rho-min_ab+1));
5393             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5394                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5395                                    + 2*w2*h3*r*sprite_ref[0][1]
5396                                    - 16*w2*h3
5397                                    + (1<<(alpha+beta+rho-min_ab+1));
5398             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5399             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5400             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5401             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5402
5403             s->sprite_shift[0]= alpha + beta + rho - min_ab;
5404             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5405             break;
5406     }
5407     /* try to simplify the situation */
5408     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5409        && s->sprite_delta[0][1] == 0
5410        && s->sprite_delta[1][0] == 0
5411        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5412     {
5413         s->sprite_offset[0][0]>>=s->sprite_shift[0];
5414         s->sprite_offset[0][1]>>=s->sprite_shift[0];
5415         s->sprite_offset[1][0]>>=s->sprite_shift[1];
5416         s->sprite_offset[1][1]>>=s->sprite_shift[1];
5417         s->sprite_delta[0][0]= a;
5418         s->sprite_delta[0][1]= 0;
5419         s->sprite_delta[1][0]= 0;
5420         s->sprite_delta[1][1]= a;
5421         s->sprite_shift[0]= 0;
5422         s->sprite_shift[1]= 0;
5423         s->real_sprite_warping_points=1;
5424     }
5425     else{
5426         int shift_y= 16 - s->sprite_shift[0];
5427         int shift_c= 16 - s->sprite_shift[1];
5428 //printf("shifts %d %d\n", shift_y, shift_c);
5429         for(i=0; i<2; i++){
5430             s->sprite_offset[0][i]<<= shift_y;
5431             s->sprite_offset[1][i]<<= shift_c;
5432             s->sprite_delta[0][i]<<= shift_y;
5433             s->sprite_delta[1][i]<<= shift_y;
5434             s->sprite_shift[i]= 16;
5435         }
5436         s->real_sprite_warping_points= s->num_sprite_warping_points;
5437     }
5438 #if 0
5439 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5440     vop_ref[0][0], vop_ref[0][1],
5441     vop_ref[1][0], vop_ref[1][1],
5442     vop_ref[2][0], vop_ref[2][1],
5443     sprite_ref[0][0], sprite_ref[0][1],
5444     sprite_ref[1][0], sprite_ref[1][1],
5445     sprite_ref[2][0], sprite_ref[2][1],
5446     virtual_ref[0][0], virtual_ref[0][1],
5447     virtual_ref[1][0], virtual_ref[1][1]
5448     );
5449
5450 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5451     s->sprite_offset[0][0], s->sprite_offset[0][1],
5452     s->sprite_delta[0][0], s->sprite_delta[0][1],
5453     s->sprite_delta[1][0], s->sprite_delta[1][1],
5454     s->sprite_shift[0]
5455     );
5456 #endif
5457 }
5458
5459 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5460     int hours, minutes, seconds;
5461
5462     hours= get_bits(gb, 5);
5463     minutes= get_bits(gb, 6);
5464     skip_bits1(gb);
5465     seconds= get_bits(gb, 6);
5466
5467     s->time_base= seconds + 60*(minutes + 60*hours);
5468
5469     skip_bits1(gb);
5470     skip_bits1(gb);
5471
5472     return 0;
5473 }
5474
5475 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5476     int width, height, vo_ver_id;
5477
5478     /* vol header */
5479     skip_bits(gb, 1); /* random access */
5480     s->vo_type= get_bits(gb, 8);
5481     if (get_bits1(gb) != 0) { /* is_ol_id */
5482         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5483         skip_bits(gb, 3); /* vo_priority */
5484     } else {
5485         vo_ver_id = 1;
5486     }
5487 //printf("vo type:%d\n",s->vo_type);
5488     s->aspect_ratio_info= get_bits(gb, 4);
5489     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5490         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5491         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5492     }else{
5493         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5494     }
5495
5496     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5497         int chroma_format= get_bits(gb, 2);
5498         if(chroma_format!=1){
5499             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5500         }
5501         s->low_delay= get_bits1(gb);
5502         if(get_bits1(gb)){ /* vbv parameters */
5503             get_bits(gb, 15);   /* first_half_bitrate */
5504             skip_bits1(gb);     /* marker */
5505             get_bits(gb, 15);   /* latter_half_bitrate */
5506             skip_bits1(gb);     /* marker */
5507             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
5508             skip_bits1(gb);     /* marker */
5509             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
5510             get_bits(gb, 11);   /* first_half_vbv_occupancy */
5511             skip_bits1(gb);     /* marker */
5512             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
5513             skip_bits1(gb);     /* marker */
5514         }
5515     }else{
5516         // set low delay flag only once the smartest? low delay detection won't be overriden
5517         if(s->picture_number==0)
5518             s->low_delay=0;
5519     }
5520
5521     s->shape = get_bits(gb, 2); /* vol shape */
5522     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5523     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5524         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5525         skip_bits(gb, 4);  //video_object_layer_shape_extension
5526     }
5527
5528     check_marker(gb, "before time_increment_resolution");
5529
5530     s->avctx->time_base.den = get_bits(gb, 16);
5531     if(!s->avctx->time_base.den){
5532         av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5533         return -1;
5534     }
5535
5536     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5537     if (s->time_increment_bits < 1)
5538         s->time_increment_bits = 1;
5539
5540     check_marker(gb, "before fixed_vop_rate");
5541
5542     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
5543         s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5544     }else
5545         s->avctx->time_base.num = 1;
5546
5547     s->t_frame=0;
5548
5549     if (s->shape != BIN_ONLY_SHAPE) {
5550         if (s->shape == RECT_SHAPE) {
5551             skip_bits1(gb);   /* marker */
5552             width = get_bits(gb, 13);
5553             skip_bits1(gb);   /* marker */
5554             height = get_bits(gb, 13);
5555             skip_bits1(gb);   /* marker */
5556             if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5557                 s->width = width;
5558                 s->height = height;
5559 //                printf("width/height: %d %d\n", width, height);
5560             }
5561         }
5562
5563         s->progressive_sequence=
5564         s->progressive_frame= get_bits1(gb)^1;
5565         s->interlaced_dct=0;
5566         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5567             av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
5568         if (vo_ver_id == 1) {
5569             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5570         } else {
5571             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5572         }
5573         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5574         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5575             if(s->vol_sprite_usage==STATIC_SPRITE){
5576                 s->sprite_width = get_bits(gb, 13);
5577                 skip_bits1(gb); /* marker */
5578                 s->sprite_height= get_bits(gb, 13);
5579                 skip_bits1(gb); /* marker */
5580                 s->sprite_left  = get_bits(gb, 13);
5581                 skip_bits1(gb); /* marker */
5582                 s->sprite_top   = get_bits(gb, 13);
5583                 skip_bits1(gb); /* marker */
5584             }
5585             s->num_sprite_warping_points= get_bits(gb, 6);
5586             if(s->num_sprite_warping_points > 3){
5587                 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
5588                 s->num_sprite_warping_points= 0;
5589                 return -1;
5590             }
5591             s->sprite_warping_accuracy = get_bits(gb, 2);
5592             s->sprite_brightness_change= get_bits1(gb);
5593             if(s->vol_sprite_usage==STATIC_SPRITE)
5594                 s->low_latency_sprite= get_bits1(gb);
5595         }
5596         // FIXME sadct disable bit if verid!=1 && shape not rect
5597
5598         if (get_bits1(gb) == 1) {   /* not_8_bit */
5599             s->quant_precision = get_bits(gb, 4); /* quant_precision */
5600             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5601             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5602         } else {
5603             s->quant_precision = 5;
5604         }
5605
5606         // FIXME a bunch of grayscale shape things
5607
5608         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5609             int i, v;
5610
5611             /* load default matrixes */
5612             for(i=0; i<64; i++){
5613                 int j= s->dsp.idct_permutation[i];
5614                 v= ff_mpeg4_default_intra_matrix[i];
5615                 s->intra_matrix[j]= v;
5616                 s->chroma_intra_matrix[j]= v;
5617
5618                 v= ff_mpeg4_default_non_intra_matrix[i];
5619                 s->inter_matrix[j]= v;
5620                 s->chroma_inter_matrix[j]= v;
5621             }
5622
5623             /* load custom intra matrix */
5624             if(get_bits1(gb)){
5625                 int last=0;
5626                 for(i=0; i<64; i++){
5627                     int j;
5628                     v= get_bits(gb, 8);
5629                     if(v==0) break;
5630
5631                     last= v;
5632                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5633                     s->intra_matrix[j]= v;
5634                     s->chroma_intra_matrix[j]= v;
5635                 }
5636
5637                 /* replicate last value */
5638                 for(; i<64; i++){
5639                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5640                     s->intra_matrix[j]= last;
5641                     s->chroma_intra_matrix[j]= last;
5642                 }
5643             }
5644
5645             /* load custom non intra matrix */
5646             if(get_bits1(gb)){
5647                 int last=0;
5648                 for(i=0; i<64; i++){
5649                     int j;
5650                     v= get_bits(gb, 8);
5651                     if(v==0) break;
5652
5653                     last= v;
5654                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5655                     s->inter_matrix[j]= v;
5656                     s->chroma_inter_matrix[j]= v;
5657                 }
5658
5659                 /* replicate last value */
5660                 for(; i<64; i++){
5661                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5662                     s->inter_matrix[j]= last;
5663                     s->chroma_inter_matrix[j]= last;
5664                 }
5665             }
5666
5667             // FIXME a bunch of grayscale shape things
5668         }
5669
5670         if(vo_ver_id != 1)
5671              s->quarter_sample= get_bits1(gb);
5672         else s->quarter_sample=0;
5673
5674         if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5675
5676         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5677
5678         s->data_partitioning= get_bits1(gb);
5679         if(s->data_partitioning){
5680             s->rvlc= get_bits1(gb);
5681         }
5682
5683         if(vo_ver_id != 1) {
5684             s->new_pred= get_bits1(gb);
5685             if(s->new_pred){
5686                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5687                 skip_bits(gb, 2); /* requested upstream message type */
5688                 skip_bits1(gb); /* newpred segment type */
5689             }
5690             s->reduced_res_vop= get_bits1(gb);
5691             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5692         }
5693         else{
5694             s->new_pred=0;
5695             s->reduced_res_vop= 0;
5696         }
5697
5698         s->scalability= get_bits1(gb);
5699
5700         if (s->scalability) {
5701             GetBitContext bak= *gb;
5702             int ref_layer_id;
5703             int ref_layer_sampling_dir;
5704             int h_sampling_factor_n;
5705             int h_sampling_factor_m;
5706             int v_sampling_factor_n;
5707             int v_sampling_factor_m;
5708
5709             s->hierachy_type= get_bits1(gb);
5710             ref_layer_id= get_bits(gb, 4);
5711             ref_layer_sampling_dir= get_bits1(gb);
5712             h_sampling_factor_n= get_bits(gb, 5);
5713             h_sampling_factor_m= get_bits(gb, 5);
5714             v_sampling_factor_n= get_bits(gb, 5);
5715             v_sampling_factor_m= get_bits(gb, 5);
5716             s->enhancement_type= get_bits1(gb);
5717
5718             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
5719                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5720
5721 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5722                 s->scalability=0;
5723
5724                 *gb= bak;
5725             }else
5726                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5727
5728             // bin shape stuff FIXME
5729         }
5730     }
5731     return 0;
5732 }
5733
5734 /**
5735  * decodes the user data stuff in the header.
5736  * allso inits divx/xvid/lavc_version/build
5737  */
5738 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5739     char buf[256];
5740     int i;
5741     int e;
5742     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5743     char last;
5744
5745     for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5746         if(show_bits(gb, 23) == 0) break;
5747         buf[i]= get_bits(gb, 8);
5748     }
5749     buf[i]=0;
5750
5751     /* divx detection */
5752     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5753     if(e<2)
5754         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5755     if(e>=2){
5756         s->divx_version= ver;
5757         s->divx_build= build;
5758         s->divx_packed= e==3 && last=='p';
5759     }
5760
5761     /* ffmpeg detection */
5762     e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5763     if(e!=4)
5764         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5765     if(e!=4){
5766         e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5767         if (e>1)
5768             build= (ver<<16) + (ver2<<8) + ver3;
5769     }
5770     if(e!=4){
5771         if(strcmp(buf, "ffmpeg")==0){
5772             s->lavc_build= 4600;
5773         }
5774     }
5775     if(e==4){
5776         s->lavc_build= build;
5777     }
5778
5779     /* xvid detection */
5780     e=sscanf(buf, "XviD%d", &build);
5781     if(e==1){
5782         s->xvid_build= build;
5783     }
5784
5785 //printf("User Data: %s\n", buf);
5786     return 0;
5787 }
5788
5789 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5790     int time_incr, time_increment;
5791
5792     s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
5793     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5794         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5795         s->low_delay=0;
5796     }
5797
5798     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5799     if(s->partitioned_frame)
5800         s->decode_mb= mpeg4_decode_partitioned_mb;
5801     else
5802         s->decode_mb= ff_mpeg4_decode_mb;
5803
5804     time_incr=0;
5805     while (get_bits1(gb) != 0)
5806         time_incr++;
5807
5808     check_marker(gb, "before time_increment");
5809
5810     if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5811         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5812
5813         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5814             if(show_bits(gb, s->time_increment_bits+1)&1) break;
5815         }
5816
5817         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5818     }
5819
5820     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5821     else time_increment= get_bits(gb, s->time_increment_bits);
5822
5823 //    printf("%d %X\n", s->time_increment_bits, time_increment);
5824 //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);
5825     if(s->pict_type!=B_TYPE){
5826         s->last_time_base= s->time_base;
5827         s->time_base+= time_incr;
5828         s->time= s->time_base*s->avctx->time_base.den + time_increment;
5829         if(s->workaround_bugs&FF_BUG_UMP4){
5830             if(s->time < s->last_non_b_time){
5831 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5832                 s->time_base++;
5833                 s->time+= s->avctx->time_base.den;
5834             }
5835         }
5836         s->pp_time= s->time - s->last_non_b_time;
5837         s->last_non_b_time= s->time;
5838     }else{
5839         s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5840         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5841         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5842 //            printf("messed up order, maybe after seeking? skipping current b frame\n");
5843             return FRAME_SKIPPED;
5844         }
5845         ff_mpeg4_init_direct_mv(s);
5846
5847         if(s->t_frame==0) s->t_frame= s->pb_time;
5848         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5849         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5850                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5851         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
5852                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5853         if(!s->progressive_sequence){
5854             if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
5855                 return FRAME_SKIPPED;
5856         }
5857     }
5858 //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);
5859
5860     if(s->avctx->time_base.num)
5861         s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5862     else
5863         s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5864     if(s->avctx->debug&FF_DEBUG_PTS)
5865         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5866
5867     check_marker(gb, "before vop_coded");
5868
5869     /* vop coded */
5870     if (get_bits1(gb) != 1){
5871         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5872             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5873         return FRAME_SKIPPED;
5874     }
5875 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5876 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5877     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5878                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5879         /* rounding type for motion estimation */
5880         s->no_rounding = get_bits1(gb);
5881     } else {
5882         s->no_rounding = 0;
5883     }
5884 //FIXME reduced res stuff
5885
5886      if (s->shape != RECT_SHAPE) {
5887          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5888              int width, height, hor_spat_ref, ver_spat_ref;
5889
5890              width = get_bits(gb, 13);
5891              skip_bits1(gb);   /* marker */
5892              height = get_bits(gb, 13);
5893              skip_bits1(gb);   /* marker */
5894              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5895              skip_bits1(gb);   /* marker */
5896              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5897          }
5898          skip_bits1(gb); /* change_CR_disable */
5899
5900          if (get_bits1(gb) != 0) {
5901              skip_bits(gb, 8); /* constant_alpha_value */
5902          }
5903      }
5904 //FIXME complexity estimation stuff
5905
5906      if (s->shape != BIN_ONLY_SHAPE) {
5907          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5908          if(!s->progressive_sequence){
5909              s->top_field_first= get_bits1(gb);
5910              s->alternate_scan= get_bits1(gb);
5911          }else
5912              s->alternate_scan= 0;
5913      }
5914
5915      if(s->alternate_scan){
5916          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
5917          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
5918          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5919          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5920      } else{
5921          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
5922          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
5923          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5924          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5925      }
5926
5927      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5928          mpeg4_decode_sprite_trajectory(s, gb);
5929          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5930          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5931      }
5932
5933      if (s->shape != BIN_ONLY_SHAPE) {
5934          s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5935          if(s->qscale==0){
5936              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5937              return -1; // makes no sense to continue, as there is nothing left from the image then
5938          }
5939
5940          if (s->pict_type != I_TYPE) {
5941              s->f_code = get_bits(gb, 3);       /* fcode_for */
5942              if(s->f_code==0){
5943                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5944                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
5945              }
5946          }else
5947              s->f_code=1;
5948
5949          if (s->pict_type == B_TYPE) {
5950              s->b_code = get_bits(gb, 3);
5951          }else
5952              s->b_code=1;
5953
5954          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5955              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",
5956                  s->qscale, s->f_code, s->b_code,
5957                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5958                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5959                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5960                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5961          }
5962
5963          if(!s->scalability){
5964              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5965                  skip_bits1(gb); // vop shape coding type
5966              }
5967          }else{
5968              if(s->enhancement_type){
5969                  int load_backward_shape= get_bits1(gb);
5970                  if(load_backward_shape){
5971                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
5972                  }
5973              }
5974              skip_bits(gb, 2); //ref_select_code
5975          }
5976      }
5977      /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
5978      // note we cannot detect divx5 without b-frames easily (although it's buggy too)
5979      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5980          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5981          s->low_delay=1;
5982      }
5983
5984      s->picture_number++; // better than pic number==0 always ;)
5985
5986      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5987      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5988
5989      if(s->workaround_bugs&FF_BUG_EDGE){
5990          s->h_edge_pos= s->width;
5991          s->v_edge_pos= s->height;
5992      }
5993      return 0;
5994 }
5995
5996 /**
5997  * decode mpeg4 headers
5998  * @return <0 if no VOP found (or a damaged one)
5999  *         FRAME_SKIPPED if a not coded VOP is found
6000  *         0 if a VOP is found
6001  */
6002 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6003 {
6004     int startcode, v;
6005
6006     /* search next start code */
6007     align_get_bits(gb);
6008
6009     if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6010         skip_bits(gb, 24);
6011         if(get_bits(gb, 8) == 0xF0)
6012             return decode_vop_header(s, gb);
6013     }
6014
6015     startcode = 0xff;
6016     for(;;) {
6017         if(get_bits_count(gb) >= gb->size_in_bits){
6018             if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6019                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6020                 return FRAME_SKIPPED; //divx bug
6021             }else
6022                 return -1; //end of stream
6023         }
6024
6025         /* use the bits after the test */
6026         v = get_bits(gb, 8);
6027         startcode = ((startcode << 8) | v) & 0xffffffff;
6028
6029         if((startcode&0xFFFFFF00) != 0x100)
6030             continue; //no startcode
6031
6032         if(s->avctx->debug&FF_DEBUG_STARTCODE){
6033             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6034             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6035             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6036             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6037             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6038             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6039             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6040             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6041             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6042             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6043             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6044             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6045             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6046             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6047             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6048             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6049             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6050             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6051             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6052             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6053             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6054             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6055             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6056             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6057             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6058             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6059             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6060             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6061             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6062         }
6063
6064         if(startcode >= 0x120 && startcode <= 0x12F){
6065             if(decode_vol_header(s, gb) < 0)
6066                 return -1;
6067         }
6068         else if(startcode == USER_DATA_STARTCODE){
6069             decode_user_data(s, gb);
6070         }
6071         else if(startcode == GOP_STARTCODE){
6072             mpeg4_decode_gop_header(s, gb);
6073         }
6074         else if(startcode == VOP_STARTCODE){
6075             return decode_vop_header(s, gb);
6076         }
6077
6078         align_get_bits(gb);
6079         startcode = 0xff;
6080     }
6081 }
6082
6083 /* don't understand why they choose a different header ! */
6084 int intel_h263_decode_picture_header(MpegEncContext *s)
6085 {
6086     int format;
6087
6088     /* picture header */
6089     if (get_bits_long(&s->gb, 22) != 0x20) {
6090         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6091         return -1;
6092     }
6093     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6094
6095     if (get_bits1(&s->gb) != 1) {
6096         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6097         return -1;      /* marker */
6098     }
6099     if (get_bits1(&s->gb) != 0) {
6100         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6101         return -1;      /* h263 id */
6102     }
6103     skip_bits1(&s->gb);         /* split screen off */
6104     skip_bits1(&s->gb);         /* camera  off */
6105     skip_bits1(&s->gb);         /* freeze picture release off */
6106
6107     format = get_bits(&s->gb, 3);
6108     if (format != 7) {
6109         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6110         return -1;
6111     }
6112     s->h263_plus = 0;
6113
6114     s->pict_type = I_TYPE + get_bits1(&s->gb);
6115
6116     s->unrestricted_mv = get_bits1(&s->gb);
6117     s->h263_long_vectors = s->unrestricted_mv;
6118
6119     if (get_bits1(&s->gb) != 0) {
6120         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6121         return -1;      /* SAC: off */
6122     }
6123     if (get_bits1(&s->gb) != 0) {
6124         s->obmc= 1;
6125         av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6126 //        return -1;      /* advanced prediction mode: off */
6127     }
6128     if (get_bits1(&s->gb) != 0) {
6129         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6130         return -1;      /* PB frame mode */
6131     }
6132
6133     /* skip unknown header garbage */
6134     skip_bits(&s->gb, 41);
6135
6136     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6137     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6138
6139     /* PEI */
6140     while (get_bits1(&s->gb) != 0) {
6141         skip_bits(&s->gb, 8);
6142     }
6143     s->f_code = 1;
6144
6145     s->y_dc_scale_table=
6146     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6147
6148     return 0;
6149 }
6150
6151 int flv_h263_decode_picture_header(MpegEncContext *s)
6152 {
6153     int format, width, height;
6154
6155     /* picture header */
6156     if (get_bits_long(&s->gb, 17) != 1) {
6157         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6158         return -1;
6159     }
6160     format = get_bits(&s->gb, 5);
6161     if (format != 0 && format != 1) {
6162         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6163         return -1;
6164     }
6165     s->h263_flv = format+1;
6166     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6167     format = get_bits(&s->gb, 3);
6168     switch (format) {
6169     case 0:
6170         width = get_bits(&s->gb, 8);
6171         height = get_bits(&s->gb, 8);
6172         break;
6173     case 1:
6174         width = get_bits(&s->gb, 16);
6175         height = get_bits(&s->gb, 16);
6176         break;
6177     case 2:
6178         width = 352;
6179         height = 288;
6180         break;
6181     case 3:
6182         width = 176;
6183         height = 144;
6184         break;
6185     case 4:
6186         width = 128;
6187         height = 96;
6188         break;
6189     case 5:
6190         width = 320;
6191         height = 240;
6192         break;
6193     case 6:
6194         width = 160;
6195         height = 120;
6196         break;
6197     default:
6198         width = height = 0;
6199         break;
6200     }
6201     if(avcodec_check_dimensions(s->avctx, width, height))
6202         return -1;
6203     s->width = width;
6204     s->height = height;
6205
6206     s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6207     s->dropable= s->pict_type > P_TYPE;
6208     if (s->dropable)
6209         s->pict_type = P_TYPE;
6210
6211     skip_bits1(&s->gb); /* deblocking flag */
6212     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6213
6214     s->h263_plus = 0;
6215
6216     s->unrestricted_mv = 1;
6217     s->h263_long_vectors = 0;
6218
6219     /* PEI */
6220     while (get_bits1(&s->gb) != 0) {
6221         skip_bits(&s->gb, 8);
6222     }
6223     s->f_code = 1;
6224
6225     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6226         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6227                s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6228     }
6229
6230     s->y_dc_scale_table=
6231     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6232
6233     return 0;
6234 }