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

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