libavcodec/h263.c

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