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