libavcodec/h263.c

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