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