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

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