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