• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/h263.c

Go to the documentation of this file.
00001 /*
00002  * H263/MPEG4 backend for ffmpeg encoder and decoder
00003  * Copyright (c) 2000,2001 Fabrice Bellard
00004  * H263+ support.
00005  * Copyright (c) 2001 Juan J. Sierralta P
00006  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
00007  *
00008  * ac prediction encoding, B-frame support, error resilience, optimizations,
00009  * qpel decoding, gmc decoding, interlaced decoding
00010  * by Michael Niedermayer <michaelni@gmx.at>
00011  *
00012  * This file is part of FFmpeg.
00013  *
00014  * FFmpeg is free software; you can redistribute it and/or
00015  * modify it under the terms of the GNU Lesser General Public
00016  * License as published by the Free Software Foundation; either
00017  * version 2.1 of the License, or (at your option) any later version.
00018  *
00019  * FFmpeg is distributed in the hope that it will be useful,
00020  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00022  * Lesser General Public License for more details.
00023  *
00024  * You should have received a copy of the GNU Lesser General Public
00025  * License along with FFmpeg; if not, write to the Free Software
00026  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00027  */
00028 
00034 //#define DEBUG
00035 #include <limits.h>
00036 
00037 #include "dsputil.h"
00038 #include "avcodec.h"
00039 #include "mpegvideo.h"
00040 #include "h263data.h"
00041 #include "mpeg4data.h"
00042 #include "mathops.h"
00043 
00044 //#undef NDEBUG
00045 //#include <assert.h>
00046 
00047 #define INTRA_MCBPC_VLC_BITS 6
00048 #define INTER_MCBPC_VLC_BITS 7
00049 #define CBPY_VLC_BITS 6
00050 #define MV_VLC_BITS 9
00051 #define DC_VLC_BITS 9
00052 #define SPRITE_TRAJ_VLC_BITS 6
00053 #define MB_TYPE_B_VLC_BITS 4
00054 #define TEX_VLC_BITS 9
00055 #define H263_MBTYPE_B_VLC_BITS 6
00056 #define CBPC_B_VLC_BITS 3
00057 
00058 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
00059                               int n);
00060 static void h263p_encode_umotion(MpegEncContext * s, int val);
00061 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
00062                                int n, int dc, uint8_t *scan_table,
00063                                PutBitContext *dc_pb, PutBitContext *ac_pb);
00064 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
00065                                   uint8_t *scan_table);
00066 
00067 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
00068 static int h263p_decode_umotion(MpegEncContext * s, int pred);
00069 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
00070                              int n, int coded);
00071 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
00072 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
00073                               int n, int coded, int intra, int rvlc);
00074 
00075 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
00076 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
00077 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
00078 
00079 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
00080 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
00081 
00082 #if CONFIG_ENCODERS
00083 static uint8_t uni_DCtab_lum_len[512];
00084 static uint8_t uni_DCtab_chrom_len[512];
00085 static uint16_t uni_DCtab_lum_bits[512];
00086 static uint16_t uni_DCtab_chrom_bits[512];
00087 
00088 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
00089 static uint8_t fcode_tab[MAX_MV*2+1];
00090 static uint8_t umv_fcode_tab[MAX_MV*2+1];
00091 
00092 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
00093 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
00094 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
00095 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
00096 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
00097 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
00098 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
00099 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
00100 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
00101 
00102 /* mpeg4
00103 inter
00104 max level: 24/6
00105 max run: 53/63
00106 
00107 intra
00108 max level: 53/16
00109 max run: 29/41
00110 */
00111 #endif
00112 
00113 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
00114 
00115 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
00116 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
00117 #else
00118 #define IS_3IV1 0
00119 #endif
00120 
00121 int h263_get_picture_format(int width, int height)
00122 {
00123     int format;
00124 
00125     if (width == 128 && height == 96)
00126         format = 1;
00127     else if (width == 176 && height == 144)
00128         format = 2;
00129     else if (width == 352 && height == 288)
00130         format = 3;
00131     else if (width == 704 && height == 576)
00132         format = 4;
00133     else if (width == 1408 && height == 1152)
00134         format = 5;
00135     else
00136         format = 7;
00137     return format;
00138 }
00139 
00140 static void show_pict_info(MpegEncContext *s){
00141     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",
00142          s->qscale, av_get_pict_type_char(s->pict_type),
00143          s->gb.size_in_bits, 1-s->no_rounding,
00144          s->obmc ? " AP" : "",
00145          s->umvplus ? " UMV" : "",
00146          s->h263_long_vectors ? " LONG" : "",
00147          s->h263_plus ? " +" : "",
00148          s->h263_aic ? " AIC" : "",
00149          s->alt_inter_vlc ? " AIV" : "",
00150          s->modified_quant ? " MQ" : "",
00151          s->loop_filter ? " LOOP" : "",
00152          s->h263_slice_structured ? " SS" : "",
00153          s->avctx->time_base.den, s->avctx->time_base.num
00154     );
00155 }
00156 
00157 #if CONFIG_ENCODERS
00158 
00159 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
00160     int i;
00161 
00162     if(aspect.num==0) aspect= (AVRational){1,1};
00163 
00164     for(i=1; i<6; i++){
00165         if(av_cmp_q(pixel_aspect[i], aspect) == 0){
00166             s->aspect_ratio_info=i;
00167             return;
00168         }
00169     }
00170 
00171     s->aspect_ratio_info= FF_ASPECT_EXTENDED;
00172 }
00173 
00174 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
00175 {
00176       int format;
00177 
00178       align_put_bits(&s->pb);
00179 
00180       put_bits(&s->pb, 17, 1);
00181       put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
00182       put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
00183                            s->avctx->time_base.den) & 0xff); /* TemporalReference */
00184       if (s->width == 352 && s->height == 288)
00185         format = 2;
00186       else if (s->width == 176 && s->height == 144)
00187         format = 3;
00188       else if (s->width == 128 && s->height == 96)
00189         format = 4;
00190       else if (s->width == 320 && s->height == 240)
00191         format = 5;
00192       else if (s->width == 160 && s->height == 120)
00193         format = 6;
00194       else if (s->width <= 255 && s->height <= 255)
00195         format = 0; /* use 1 byte width & height */
00196       else
00197         format = 1; /* use 2 bytes width & height */
00198       put_bits(&s->pb, 3, format); /* PictureSize */
00199       if (format == 0) {
00200         put_bits(&s->pb, 8, s->width);
00201         put_bits(&s->pb, 8, s->height);
00202       } else if (format == 1) {
00203         put_bits(&s->pb, 16, s->width);
00204         put_bits(&s->pb, 16, s->height);
00205       }
00206       put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */
00207       put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
00208       put_bits(&s->pb, 5, s->qscale); /* Quantizer */
00209       put_bits(&s->pb, 1, 0); /* ExtraInformation */
00210 
00211       if(s->h263_aic){
00212         s->y_dc_scale_table=
00213           s->c_dc_scale_table= ff_aic_dc_scale_table;
00214       }else{
00215         s->y_dc_scale_table=
00216           s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00217       }
00218 }
00219 
00220 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
00221 {
00222     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
00223     int best_clock_code=1;
00224     int best_divisor=60;
00225     int best_error= INT_MAX;
00226 
00227     if(s->h263_plus){
00228         for(i=0; i<2; i++){
00229             int div, error;
00230             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
00231             div= av_clip(div, 1, 127);
00232             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
00233             if(error < best_error){
00234                 best_error= error;
00235                 best_divisor= div;
00236                 best_clock_code= i;
00237             }
00238         }
00239     }
00240     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
00241     coded_frame_rate= 1800000;
00242     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
00243 
00244     align_put_bits(&s->pb);
00245 
00246     /* Update the pointer to last GOB */
00247     s->ptr_lastgob = pbBufPtr(&s->pb);
00248     put_bits(&s->pb, 22, 0x20); /* PSC */
00249     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
00250                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
00251     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
00252 
00253     put_bits(&s->pb, 1, 1);     /* marker */
00254     put_bits(&s->pb, 1, 0);     /* h263 id */
00255     put_bits(&s->pb, 1, 0);     /* split screen off */
00256     put_bits(&s->pb, 1, 0);     /* camera  off */
00257     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
00258 
00259     format = h263_get_picture_format(s->width, s->height);
00260     if (!s->h263_plus) {
00261         /* H.263v1 */
00262         put_bits(&s->pb, 3, format);
00263         put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
00264         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
00265         of H.263v1 UMV implies to check the predicted MV after
00266         calculation of the current MB to see if we're on the limits */
00267         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
00268         put_bits(&s->pb, 1, 0);         /* SAC: off */
00269         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
00270         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
00271         put_bits(&s->pb, 5, s->qscale);
00272         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
00273     } else {
00274         int ufep=1;
00275         /* H.263v2 */
00276         /* H.263 Plus PTYPE */
00277 
00278         put_bits(&s->pb, 3, 7);
00279         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
00280         if (format == 7)
00281             put_bits(&s->pb,3,6); /* Custom Source Format */
00282         else
00283             put_bits(&s->pb, 3, format);
00284 
00285         put_bits(&s->pb,1, s->custom_pcf);
00286         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
00287         put_bits(&s->pb,1,0); /* SAC: off */
00288         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
00289         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
00290         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
00291         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
00292         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
00293         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
00294         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
00295         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
00296         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
00297         put_bits(&s->pb,3,0); /* Reserved */
00298 
00299         put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
00300 
00301         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
00302         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
00303         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
00304         put_bits(&s->pb,2,0); /* Reserved */
00305         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
00306 
00307         /* This should be here if PLUSPTYPE */
00308         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
00309 
00310                 if (format == 7) {
00311             /* Custom Picture Format (CPFMT) */
00312             aspect_to_info(s, s->avctx->sample_aspect_ratio);
00313 
00314             put_bits(&s->pb,4,s->aspect_ratio_info);
00315             put_bits(&s->pb,9,(s->width >> 2) - 1);
00316             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
00317             put_bits(&s->pb,9,(s->height >> 2));
00318             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
00319                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
00320                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
00321             }
00322         }
00323         if(s->custom_pcf){
00324             if(ufep){
00325                 put_bits(&s->pb, 1, best_clock_code);
00326                 put_bits(&s->pb, 7, best_divisor);
00327             }
00328             put_sbits(&s->pb, 2, temp_ref>>8);
00329         }
00330 
00331         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
00332         if (s->umvplus)
00333 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
00334 //FIXME check actual requested range
00335             put_bits(&s->pb,2,1); /* unlimited */
00336         if(s->h263_slice_structured)
00337             put_bits(&s->pb,2,0); /* no weird submodes */
00338 
00339         put_bits(&s->pb, 5, s->qscale);
00340     }
00341 
00342     put_bits(&s->pb, 1, 0);     /* no PEI */
00343 
00344     if(s->h263_slice_structured){
00345         put_bits(&s->pb, 1, 1);
00346 
00347         assert(s->mb_x == 0 && s->mb_y == 0);
00348         ff_h263_encode_mba(s);
00349 
00350         put_bits(&s->pb, 1, 1);
00351     }
00352 
00353     if(s->h263_aic){
00354          s->y_dc_scale_table=
00355          s->c_dc_scale_table= ff_aic_dc_scale_table;
00356     }else{
00357         s->y_dc_scale_table=
00358         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00359     }
00360 }
00361 
00365 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
00366 {
00367     put_bits(&s->pb, 17, 1); /* GBSC */
00368 
00369     if(s->h263_slice_structured){
00370         put_bits(&s->pb, 1, 1);
00371 
00372         ff_h263_encode_mba(s);
00373 
00374         if(s->mb_num > 1583)
00375             put_bits(&s->pb, 1, 1);
00376         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
00377         put_bits(&s->pb, 1, 1);
00378         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
00379     }else{
00380         int gob_number= mb_line / s->gob_index;
00381 
00382         put_bits(&s->pb, 5, gob_number); /* GN */
00383         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
00384         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
00385     }
00386 }
00387 
00388 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
00389     int last=0;
00390     int j;
00391     int rate=0;
00392 
00393     for(j=1; j<=block_last_index; j++){
00394         const int index= scantable[j];
00395         int level= block[index];
00396         if(level){
00397             level+= 64;
00398             if((level&(~127)) == 0){
00399                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
00400                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
00401             }else
00402                 rate += s->ac_esc_length;
00403             level-= 64;
00404 
00405             last= j;
00406         }
00407     }
00408 
00409     return rate;
00410 }
00411 
00412 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00413 {
00414     int score= 0;
00415     int i, n;
00416     int8_t * const qscale_table= s->current_picture.qscale_table;
00417 
00418     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
00419 
00420     for(n=0; n<6; n++){
00421         int16_t *ac_val, *ac_val1;
00422 
00423         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
00424 
00425         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00426         ac_val1= ac_val;
00427         if(dir[n]){
00428             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00429             /* top prediction */
00430             ac_val-= s->block_wrap[n]*16;
00431             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00432                 /* same qscale */
00433                 for(i=1; i<8; i++){
00434                     const int level= block[n][s->dsp.idct_permutation[i   ]];
00435                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
00436                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
00437                     ac_val1[i+8]= level;
00438                 }
00439             }else{
00440                 /* different qscale, we must rescale */
00441                 for(i=1; i<8; i++){
00442                     const int level= block[n][s->dsp.idct_permutation[i   ]];
00443                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00444                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
00445                     ac_val1[i+8]= level;
00446                 }
00447             }
00448             st[n]= s->intra_h_scantable.permutated;
00449         }else{
00450             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00451             /* left prediction */
00452             ac_val-= 16;
00453             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00454                 /* same qscale */
00455                 for(i=1; i<8; i++){
00456                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
00457                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
00458                     ac_val1[i  ]= level;
00459                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
00460                 }
00461             }else{
00462                 /* different qscale, we must rescale */
00463                 for(i=1; i<8; i++){
00464                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
00465                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00466                     ac_val1[i  ]= level;
00467                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
00468                 }
00469             }
00470             st[n]= s->intra_v_scantable.permutated;
00471         }
00472 
00473         for(i=63; i>0; i--) //FIXME optimize
00474             if(block[n][ st[n][i] ]) break;
00475         s->block_last_index[n]= i;
00476 
00477         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
00478     }
00479 
00480     return score < 0;
00481 }
00482 
00483 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00484 {
00485     int i, n;
00486     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
00487 
00488     for(n=0; n<6; n++){
00489         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00490 
00491         st[n]= s->intra_scantable.permutated;
00492         if(dir[n]){
00493             /* top prediction */
00494             for(i=1; i<8; i++){
00495                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
00496             }
00497         }else{
00498             /* left prediction */
00499             for(i=1; i<8; i++){
00500                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
00501             }
00502         }
00503     }
00504 }
00505 
00509 static void ff_init_qscale_tab(MpegEncContext *s){
00510     int8_t * const qscale_table= s->current_picture.qscale_table;
00511     int i;
00512 
00513     for(i=0; i<s->mb_num; i++){
00514         unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
00515         int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
00516         qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
00517     }
00518 }
00519 
00523 void ff_clean_h263_qscales(MpegEncContext *s){
00524     int i;
00525     int8_t * const qscale_table= s->current_picture.qscale_table;
00526 
00527     ff_init_qscale_tab(s);
00528 
00529     for(i=1; i<s->mb_num; i++){
00530         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
00531             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
00532     }
00533     for(i=s->mb_num-2; i>=0; i--){
00534         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
00535             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
00536     }
00537 
00538     if(s->codec_id != CODEC_ID_H263P){
00539         for(i=1; i<s->mb_num; i++){
00540             int mb_xy= s->mb_index2xy[i];
00541 
00542             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
00543                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
00544             }
00545         }
00546     }
00547 }
00548 
00552 void ff_clean_mpeg4_qscales(MpegEncContext *s){
00553     int i;
00554     int8_t * const qscale_table= s->current_picture.qscale_table;
00555 
00556     ff_clean_h263_qscales(s);
00557 
00558     if(s->pict_type== FF_B_TYPE){
00559         int odd=0;
00560         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
00561 
00562         for(i=0; i<s->mb_num; i++){
00563             int mb_xy= s->mb_index2xy[i];
00564             odd += qscale_table[mb_xy]&1;
00565         }
00566 
00567         if(2*odd > s->mb_num) odd=1;
00568         else                  odd=0;
00569 
00570         for(i=0; i<s->mb_num; i++){
00571             int mb_xy= s->mb_index2xy[i];
00572             if((qscale_table[mb_xy]&1) != odd)
00573                 qscale_table[mb_xy]++;
00574             if(qscale_table[mb_xy] > 31)
00575                 qscale_table[mb_xy]= 31;
00576         }
00577 
00578         for(i=1; i<s->mb_num; i++){
00579             int mb_xy= s->mb_index2xy[i];
00580             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
00581                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
00582             }
00583         }
00584     }
00585 }
00586 
00587 #endif //CONFIG_ENCODERS
00588 
00589 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
00590 #define tab_bias (tab_size/2)
00591 
00592 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
00593     int i;
00594     for(i=0; i<tab_size; i++){
00595         s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
00596         s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
00597     }
00598 }
00599 
00600 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
00601     int xy= s->block_index[i];
00602     uint16_t time_pp= s->pp_time;
00603     uint16_t time_pb= s->pb_time;
00604     int p_mx, p_my;
00605 
00606     p_mx= s->next_picture.motion_val[0][xy][0];
00607     if((unsigned)(p_mx + tab_bias) < tab_size){
00608         s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
00609         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
00610                             : s->direct_scale_mv[1][p_mx + tab_bias];
00611     }else{
00612         s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
00613         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
00614                             : p_mx*(time_pb - time_pp)/time_pp;
00615     }
00616     p_my= s->next_picture.motion_val[0][xy][1];
00617     if((unsigned)(p_my + tab_bias) < tab_size){
00618         s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
00619         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
00620                             : s->direct_scale_mv[1][p_my + tab_bias];
00621     }else{
00622         s->mv[0][i][1] = p_my*time_pb/time_pp + my;
00623         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
00624                             : p_my*(time_pb - time_pp)/time_pp;
00625     }
00626 }
00627 
00628 #undef tab_size
00629 #undef tab_bias
00630 
00635 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
00636     const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
00637     const int colocated_mb_type= s->next_picture.mb_type[mb_index];
00638     uint16_t time_pp= s->pp_time;
00639     uint16_t time_pb= s->pb_time;
00640     int i;
00641 
00642     //FIXME avoid divides
00643     // try special case with shifts for 1 and 3 B-frames?
00644 
00645     if(IS_8X8(colocated_mb_type)){
00646         s->mv_type = MV_TYPE_8X8;
00647         for(i=0; i<4; i++){
00648             ff_mpeg4_set_one_direct_mv(s, mx, my, i);
00649         }
00650         return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
00651     } else if(IS_INTERLACED(colocated_mb_type)){
00652         s->mv_type = MV_TYPE_FIELD;
00653         for(i=0; i<2; i++){
00654             int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
00655             s->field_select[0][i]= field_select;
00656             s->field_select[1][i]= i;
00657             if(s->top_field_first){
00658                 time_pp= s->pp_field_time - field_select + i;
00659                 time_pb= s->pb_field_time - field_select + i;
00660             }else{
00661                 time_pp= s->pp_field_time + field_select - i;
00662                 time_pb= s->pb_field_time + field_select - i;
00663             }
00664             s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
00665             s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
00666             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
00667                                 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
00668             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
00669                                 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
00670         }
00671         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
00672     }else{
00673         ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
00674         s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
00675         s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
00676         s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
00677         s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
00678         if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
00679             s->mv_type= MV_TYPE_16X16;
00680         else
00681             s->mv_type= MV_TYPE_8X8;
00682         return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
00683     }
00684 }
00685 
00686 void ff_h263_update_motion_val(MpegEncContext * s){
00687     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
00688                //FIXME a lot of that is only needed for !low_delay
00689     const int wrap = s->b8_stride;
00690     const int xy = s->block_index[0];
00691 
00692     s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
00693 
00694     if(s->mv_type != MV_TYPE_8X8){
00695         int motion_x, motion_y;
00696         if (s->mb_intra) {
00697             motion_x = 0;
00698             motion_y = 0;
00699         } else if (s->mv_type == MV_TYPE_16X16) {
00700             motion_x = s->mv[0][0][0];
00701             motion_y = s->mv[0][0][1];
00702         } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
00703             int i;
00704             motion_x = s->mv[0][0][0] + s->mv[0][1][0];
00705             motion_y = s->mv[0][0][1] + s->mv[0][1][1];
00706             motion_x = (motion_x>>1) | (motion_x&1);
00707             for(i=0; i<2; i++){
00708                 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
00709                 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
00710             }
00711             s->current_picture.ref_index[0][xy           ]=
00712             s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
00713             s->current_picture.ref_index[0][xy + wrap    ]=
00714             s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
00715         }
00716 
00717         /* no update if 8X8 because it has been done during parsing */
00718         s->current_picture.motion_val[0][xy][0] = motion_x;
00719         s->current_picture.motion_val[0][xy][1] = motion_y;
00720         s->current_picture.motion_val[0][xy + 1][0] = motion_x;
00721         s->current_picture.motion_val[0][xy + 1][1] = motion_y;
00722         s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
00723         s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
00724         s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
00725         s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
00726     }
00727 
00728     if(s->encoding){ //FIXME encoding MUST be cleaned up
00729         if (s->mv_type == MV_TYPE_8X8)
00730             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
00731         else if(s->mb_intra)
00732             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
00733         else
00734             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
00735     }
00736 }
00737 
00738 #if CONFIG_ENCODERS
00739 
00740 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
00741     int l, bit_size, code;
00742 
00743     if (val == 0) {
00744         return mvtab[0][1];
00745     } else {
00746         bit_size = f_code - 1;
00747         /* modulo encoding */
00748         l= INT_BIT - 6 - bit_size;
00749         val = (val<<l)>>l;
00750         val--;
00751         code = (val >> bit_size) + 1;
00752 
00753         return mvtab[code][1] + 1 + bit_size;
00754     }
00755 }
00756 
00757 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
00758     if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00759         skip_put_bits(&s->pb,
00760             h263_get_motion_length(s, x, f_code)
00761            +h263_get_motion_length(s, y, f_code));
00762     }else{
00763         ff_h263_encode_motion(s, x, f_code);
00764         ff_h263_encode_motion(s, y, f_code);
00765     }
00766 }
00767 
00768 static inline int get_p_cbp(MpegEncContext * s,
00769                       DCTELEM block[6][64],
00770                       int motion_x, int motion_y){
00771     int cbp, i;
00772 
00773     if(s->flags & CODEC_FLAG_CBP_RD){
00774         int best_cbpy_score= INT_MAX;
00775         int best_cbpc_score= INT_MAX;
00776         int cbpc = (-1), cbpy= (-1);
00777         const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
00778         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00779 
00780         for(i=0; i<4; i++){
00781             int score= inter_MCBPC_bits[i + offset] * lambda;
00782             if(i&1) score += s->coded_score[5];
00783             if(i&2) score += s->coded_score[4];
00784 
00785             if(score < best_cbpc_score){
00786                 best_cbpc_score= score;
00787                 cbpc= i;
00788             }
00789         }
00790 
00791         for(i=0; i<16; i++){
00792             int score= cbpy_tab[i ^ 0xF][1] * lambda;
00793             if(i&1) score += s->coded_score[3];
00794             if(i&2) score += s->coded_score[2];
00795             if(i&4) score += s->coded_score[1];
00796             if(i&8) score += s->coded_score[0];
00797 
00798             if(score < best_cbpy_score){
00799                 best_cbpy_score= score;
00800                 cbpy= i;
00801             }
00802         }
00803         cbp= cbpc + 4*cbpy;
00804         if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
00805             if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
00806                 cbp= 0;
00807         }
00808 
00809         for (i = 0; i < 6; i++) {
00810             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
00811                 s->block_last_index[i]= -1;
00812                 s->dsp.clear_block(s->block[i]);
00813             }
00814         }
00815     }else{
00816         cbp= 0;
00817         for (i = 0; i < 6; i++) {
00818             if (s->block_last_index[i] >= 0)
00819                 cbp |= 1 << (5 - i);
00820         }
00821     }
00822     return cbp;
00823 }
00824 
00825 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
00826                             int motion_x, int motion_y, int mb_type){
00827     int cbp=0, i;
00828 
00829     if(s->flags & CODEC_FLAG_CBP_RD){
00830         int score=0;
00831         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00832 
00833         for(i=0; i<6; i++){
00834             if(s->coded_score[i] < 0){
00835                 score += s->coded_score[i];
00836                 cbp |= 1 << (5 - i);
00837             }
00838         }
00839 
00840         if(cbp){
00841             int zero_score= -6;
00842             if ((motion_x | motion_y | s->dquant | mb_type) == 0){
00843                 zero_score-= 4; //2*MV + mb_type + cbp bit
00844             }
00845 
00846             zero_score*= lambda;
00847             if(zero_score <= score){
00848                 cbp=0;
00849             }
00850         }
00851 
00852         for (i = 0; i < 6; i++) {
00853             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
00854                 s->block_last_index[i]= -1;
00855                 s->dsp.clear_block(s->block[i]);
00856             }
00857         }
00858     }else{
00859         for (i = 0; i < 6; i++) {
00860             if (s->block_last_index[i] >= 0)
00861                 cbp |= 1 << (5 - i);
00862         }
00863     }
00864     return cbp;
00865 }
00866 
00867 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
00868                                uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
00869     int i;
00870 
00871     if(scan_table){
00872         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00873             for (i = 0; i < 6; i++) {
00874                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
00875             }
00876         }else{
00877             /* encode each block */
00878             for (i = 0; i < 6; i++) {
00879                 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
00880             }
00881         }
00882     }else{
00883         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00884             for (i = 0; i < 6; i++) {
00885                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
00886             }
00887         }else{
00888             /* encode each block */
00889             for (i = 0; i < 6; i++) {
00890                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
00891             }
00892         }
00893     }
00894 }
00895 
00896 static const int dquant_code[5]= {1,0,9,2,3};
00897 
00898 void mpeg4_encode_mb(MpegEncContext * s,
00899                     DCTELEM block[6][64],
00900                     int motion_x, int motion_y)
00901 {
00902     int cbpc, cbpy, pred_x, pred_y;
00903     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
00904     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb;
00905     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2    : &s->pb;
00906     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
00907 
00908     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00909     if (!s->mb_intra) {
00910         int i, cbp;
00911 
00912         if(s->pict_type==FF_B_TYPE){
00913             static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
00914             int mb_type=  mb_type_table[s->mv_dir];
00915 
00916             if(s->mb_x==0){
00917                 for(i=0; i<2; i++){
00918                     s->last_mv[i][0][0]=
00919                     s->last_mv[i][0][1]=
00920                     s->last_mv[i][1][0]=
00921                     s->last_mv[i][1][1]= 0;
00922                 }
00923             }
00924 
00925             assert(s->dquant>=-2 && s->dquant<=2);
00926             assert((s->dquant&1)==0);
00927             assert(mb_type>=0);
00928 
00929             /* nothing to do if this MB was skipped in the next P Frame */
00930             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
00931                 s->skip_count++;
00932                 s->mv[0][0][0]=
00933                 s->mv[0][0][1]=
00934                 s->mv[1][0][0]=
00935                 s->mv[1][0][1]= 0;
00936                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
00937                 s->qscale -= s->dquant;
00938 //                s->mb_skipped=1;
00939 
00940                 return;
00941             }
00942 
00943             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
00944 
00945             if ((cbp | motion_x | motion_y | mb_type) ==0) {
00946                 /* direct MB with MV={0,0} */
00947                 assert(s->dquant==0);
00948 
00949                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
00950 
00951                 if(interleaved_stats){
00952                     s->misc_bits++;
00953                     s->last_bits++;
00954                 }
00955                 s->skip_count++;
00956                 return;
00957             }
00958 
00959             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
00960             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
00961             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
00962             if(cbp) put_bits(&s->pb, 6, cbp);
00963 
00964             if(cbp && mb_type){
00965                 if(s->dquant)
00966                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
00967                 else
00968                     put_bits(&s->pb, 1, 0);
00969             }else
00970                 s->qscale -= s->dquant;
00971 
00972             if(!s->progressive_sequence){
00973                 if(cbp)
00974                     put_bits(&s->pb, 1, s->interlaced_dct);
00975                 if(mb_type) // not direct mode
00976                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
00977             }
00978 
00979             if(interleaved_stats){
00980                 s->misc_bits+= get_bits_diff(s);
00981             }
00982 
00983             if(mb_type == 0){
00984                 assert(s->mv_dir & MV_DIRECT);
00985                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
00986                 s->b_count++;
00987                 s->f_count++;
00988             }else{
00989                 assert(mb_type > 0 && mb_type < 4);
00990                 if(s->mv_type != MV_TYPE_FIELD){
00991                     if(s->mv_dir & MV_DIR_FORWARD){
00992                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
00993                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
00994                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
00995                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
00996                         s->f_count++;
00997                     }
00998                     if(s->mv_dir & MV_DIR_BACKWARD){
00999                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
01000                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
01001                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
01002                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
01003                         s->b_count++;
01004                     }
01005                 }else{
01006                     if(s->mv_dir & MV_DIR_FORWARD){
01007                         put_bits(&s->pb, 1, s->field_select[0][0]);
01008                         put_bits(&s->pb, 1, s->field_select[0][1]);
01009                     }
01010                     if(s->mv_dir & MV_DIR_BACKWARD){
01011                         put_bits(&s->pb, 1, s->field_select[1][0]);
01012                         put_bits(&s->pb, 1, s->field_select[1][1]);
01013                     }
01014                     if(s->mv_dir & MV_DIR_FORWARD){
01015                         for(i=0; i<2; i++){
01016                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
01017                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
01018                             s->last_mv[0][i][0]= s->mv[0][i][0];
01019                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
01020                         }
01021                         s->f_count++;
01022                     }
01023                     if(s->mv_dir & MV_DIR_BACKWARD){
01024                         for(i=0; i<2; i++){
01025                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
01026                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
01027                             s->last_mv[1][i][0]= s->mv[1][i][0];
01028                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
01029                         }
01030                         s->b_count++;
01031                     }
01032                 }
01033             }
01034 
01035             if(interleaved_stats){
01036                 s->mv_bits+= get_bits_diff(s);
01037             }
01038 
01039             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
01040 
01041             if(interleaved_stats){
01042                 s->p_tex_bits+= get_bits_diff(s);
01043             }
01044 
01045         }else{ /* s->pict_type==FF_B_TYPE */
01046             cbp= get_p_cbp(s, block, motion_x, motion_y);
01047 
01048             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
01049                 /* check if the B frames can skip it too, as we must skip it if we skip here
01050                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
01051                 if(s->max_b_frames>0){
01052                     int i;
01053                     int x,y, offset;
01054                     uint8_t *p_pic;
01055 
01056                     x= s->mb_x*16;
01057                     y= s->mb_y*16;
01058                     if(x+16 > s->width)  x= s->width-16;
01059                     if(y+16 > s->height) y= s->height-16;
01060 
01061                     offset= x + y*s->linesize;
01062                     p_pic= s->new_picture.data[0] + offset;
01063 
01064                     s->mb_skipped=1;
01065                     for(i=0; i<s->max_b_frames; i++){
01066                         uint8_t *b_pic;
01067                         int diff;
01068                         Picture *pic= s->reordered_input_picture[i+1];
01069 
01070                         if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
01071 
01072                         b_pic= pic->data[0] + offset;
01073                         if(pic->type != FF_BUFFER_TYPE_SHARED)
01074                             b_pic+= INPLACE_OFFSET;
01075                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
01076                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
01077                             s->mb_skipped=0;
01078                             break;
01079                         }
01080                     }
01081                 }else
01082                     s->mb_skipped=1;
01083 
01084                 if(s->mb_skipped==1){
01085                     /* skip macroblock */
01086                     put_bits(&s->pb, 1, 1);
01087 
01088                     if(interleaved_stats){
01089                         s->misc_bits++;
01090                         s->last_bits++;
01091                     }
01092                     s->skip_count++;
01093 
01094                     return;
01095                 }
01096             }
01097 
01098             put_bits(&s->pb, 1, 0);     /* mb coded */
01099             cbpc = cbp & 3;
01100             cbpy = cbp >> 2;
01101             cbpy ^= 0xf;
01102             if(s->mv_type==MV_TYPE_16X16){
01103                 if(s->dquant) cbpc+= 8;
01104                 put_bits(&s->pb,
01105                         inter_MCBPC_bits[cbpc],
01106                         inter_MCBPC_code[cbpc]);
01107 
01108                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01109                 if(s->dquant)
01110                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
01111 
01112                 if(!s->progressive_sequence){
01113                     if(cbp)
01114                         put_bits(pb2, 1, s->interlaced_dct);
01115                     put_bits(pb2, 1, 0);
01116                 }
01117 
01118                 if(interleaved_stats){
01119                     s->misc_bits+= get_bits_diff(s);
01120                 }
01121 
01122                 /* motion vectors: 16x16 mode */
01123                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01124 
01125                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01126                                                 motion_y - pred_y, s->f_code);
01127             }else if(s->mv_type==MV_TYPE_FIELD){
01128                 if(s->dquant) cbpc+= 8;
01129                 put_bits(&s->pb,
01130                         inter_MCBPC_bits[cbpc],
01131                         inter_MCBPC_code[cbpc]);
01132 
01133                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01134                 if(s->dquant)
01135                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
01136 
01137                 assert(!s->progressive_sequence);
01138                 if(cbp)
01139                     put_bits(pb2, 1, s->interlaced_dct);
01140                 put_bits(pb2, 1, 1);
01141 
01142                 if(interleaved_stats){
01143                     s->misc_bits+= get_bits_diff(s);
01144                 }
01145 
01146                 /* motion vectors: 16x8 interlaced mode */
01147                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01148                 pred_y /=2;
01149 
01150                 put_bits(&s->pb, 1, s->field_select[0][0]);
01151                 put_bits(&s->pb, 1, s->field_select[0][1]);
01152 
01153                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
01154                                                 s->mv[0][0][1] - pred_y, s->f_code);
01155                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
01156                                                 s->mv[0][1][1] - pred_y, s->f_code);
01157             }else{
01158                 assert(s->mv_type==MV_TYPE_8X8);
01159                 put_bits(&s->pb,
01160                         inter_MCBPC_bits[cbpc+16],
01161                         inter_MCBPC_code[cbpc+16]);
01162                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01163 
01164                 if(!s->progressive_sequence){
01165                     if(cbp)
01166                         put_bits(pb2, 1, s->interlaced_dct);
01167                 }
01168 
01169                 if(interleaved_stats){
01170                     s->misc_bits+= get_bits_diff(s);
01171                 }
01172 
01173                 for(i=0; i<4; i++){
01174                     /* motion vectors: 8x8 mode*/
01175                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01176 
01177                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
01178                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
01179                 }
01180             }
01181 
01182             if(interleaved_stats){
01183                 s->mv_bits+= get_bits_diff(s);
01184             }
01185 
01186             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
01187 
01188             if(interleaved_stats){
01189                 s->p_tex_bits+= get_bits_diff(s);
01190             }
01191             s->f_count++;
01192         }
01193     } else {
01194         int cbp;
01195         int dc_diff[6];   //dc values with the dc prediction subtracted
01196         int dir[6];  //prediction direction
01197         int zigzag_last_index[6];
01198         uint8_t *scan_table[6];
01199         int i;
01200 
01201         for(i=0; i<6; i++){
01202             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
01203         }
01204 
01205         if(s->flags & CODEC_FLAG_AC_PRED){
01206             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
01207             if(!s->ac_pred)
01208                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
01209         }else{
01210             for(i=0; i<6; i++)
01211                 scan_table[i]= s->intra_scantable.permutated;
01212         }
01213 
01214         /* compute cbp */
01215         cbp = 0;
01216         for (i = 0; i < 6; i++) {
01217             if (s->block_last_index[i] >= 1)
01218                 cbp |= 1 << (5 - i);
01219         }
01220 
01221         cbpc = cbp & 3;
01222         if (s->pict_type == FF_I_TYPE) {
01223             if(s->dquant) cbpc+=4;
01224             put_bits(&s->pb,
01225                 intra_MCBPC_bits[cbpc],
01226                 intra_MCBPC_code[cbpc]);
01227         } else {
01228             if(s->dquant) cbpc+=8;
01229             put_bits(&s->pb, 1, 0);     /* mb coded */
01230             put_bits(&s->pb,
01231                 inter_MCBPC_bits[cbpc + 4],
01232                 inter_MCBPC_code[cbpc + 4]);
01233         }
01234         put_bits(pb2, 1, s->ac_pred);
01235         cbpy = cbp >> 2;
01236         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01237         if(s->dquant)
01238             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
01239 
01240         if(!s->progressive_sequence){
01241             put_bits(dc_pb, 1, s->interlaced_dct);
01242         }
01243 
01244         if(interleaved_stats){
01245             s->misc_bits+= get_bits_diff(s);
01246         }
01247 
01248         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
01249 
01250         if(interleaved_stats){
01251             s->i_tex_bits+= get_bits_diff(s);
01252         }
01253         s->i_count++;
01254 
01255         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
01256         if(s->ac_pred)
01257             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
01258     }
01259 }
01260 
01261 void h263_encode_mb(MpegEncContext * s,
01262                     DCTELEM block[6][64],
01263                     int motion_x, int motion_y)
01264 {
01265     int cbpc, cbpy, i, cbp, pred_x, pred_y;
01266     int16_t pred_dc;
01267     int16_t rec_intradc[6];
01268     int16_t *dc_ptr[6];
01269     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
01270 
01271     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
01272     if (!s->mb_intra) {
01273         /* compute cbp */
01274         cbp= get_p_cbp(s, block, motion_x, motion_y);
01275 
01276         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
01277             /* skip macroblock */
01278             put_bits(&s->pb, 1, 1);
01279             if(interleaved_stats){
01280                 s->misc_bits++;
01281                 s->last_bits++;
01282             }
01283             s->skip_count++;
01284 
01285             return;
01286         }
01287         put_bits(&s->pb, 1, 0);         /* mb coded */
01288 
01289         cbpc = cbp & 3;
01290         cbpy = cbp >> 2;
01291         if(s->alt_inter_vlc==0 || cbpc!=3)
01292             cbpy ^= 0xF;
01293         if(s->dquant) cbpc+= 8;
01294         if(s->mv_type==MV_TYPE_16X16){
01295             put_bits(&s->pb,
01296                     inter_MCBPC_bits[cbpc],
01297                     inter_MCBPC_code[cbpc]);
01298 
01299             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01300             if(s->dquant)
01301                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01302 
01303             if(interleaved_stats){
01304                 s->misc_bits+= get_bits_diff(s);
01305             }
01306 
01307             /* motion vectors: 16x16 mode */
01308             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01309 
01310             if (!s->umvplus) {
01311                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01312                                                 motion_y - pred_y, 1);
01313             }
01314             else {
01315                 h263p_encode_umotion(s, motion_x - pred_x);
01316                 h263p_encode_umotion(s, motion_y - pred_y);
01317                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
01318                     /* To prevent Start Code emulation */
01319                     put_bits(&s->pb,1,1);
01320             }
01321         }else{
01322             put_bits(&s->pb,
01323                     inter_MCBPC_bits[cbpc+16],
01324                     inter_MCBPC_code[cbpc+16]);
01325             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01326             if(s->dquant)
01327                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01328 
01329             if(interleaved_stats){
01330                 s->misc_bits+= get_bits_diff(s);
01331             }
01332 
01333             for(i=0; i<4; i++){
01334                 /* motion vectors: 8x8 mode*/
01335                 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01336 
01337                 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
01338                 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
01339                 if (!s->umvplus) {
01340                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
01341                                                     motion_y - pred_y, 1);
01342                 }
01343                 else {
01344                     h263p_encode_umotion(s, motion_x - pred_x);
01345                     h263p_encode_umotion(s, motion_y - pred_y);
01346                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
01347                         /* To prevent Start Code emulation */
01348                         put_bits(&s->pb,1,1);
01349                 }
01350             }
01351         }
01352 
01353         if(interleaved_stats){
01354             s->mv_bits+= get_bits_diff(s);
01355         }
01356     } else {
01357         assert(s->mb_intra);
01358 
01359         cbp = 0;
01360         if (s->h263_aic) {
01361             /* Predict DC */
01362             for(i=0; i<6; i++) {
01363                 int16_t level = block[i][0];
01364                 int scale;
01365 
01366                 if(i<4) scale= s->y_dc_scale;
01367                 else    scale= s->c_dc_scale;
01368 
01369                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
01370                 level -= pred_dc;
01371                 /* Quant */
01372                 if (level >= 0)
01373                     level = (level + (scale>>1))/scale;
01374                 else
01375                     level = (level - (scale>>1))/scale;
01376 
01377                 /* AIC can change CBP */
01378                 if (level == 0 && s->block_last_index[i] == 0)
01379                     s->block_last_index[i] = -1;
01380 
01381                 if(!s->modified_quant){
01382                     if (level < -127)
01383                         level = -127;
01384                     else if (level > 127)
01385                         level = 127;
01386                 }
01387 
01388                 block[i][0] = level;
01389                 /* Reconstruction */
01390                 rec_intradc[i] = scale*level + pred_dc;
01391                 /* Oddify */
01392                 rec_intradc[i] |= 1;
01393                 //if ((rec_intradc[i] % 2) == 0)
01394                 //    rec_intradc[i]++;
01395                 /* Clipping */
01396                 if (rec_intradc[i] < 0)
01397                     rec_intradc[i] = 0;
01398                 else if (rec_intradc[i] > 2047)
01399                     rec_intradc[i] = 2047;
01400 
01401                 /* Update AC/DC tables */
01402                 *dc_ptr[i] = rec_intradc[i];
01403                 if (s->block_last_index[i] >= 0)
01404                     cbp |= 1 << (5 - i);
01405             }
01406         }else{
01407             for(i=0; i<6; i++) {
01408                 /* compute cbp */
01409                 if (s->block_last_index[i] >= 1)
01410                     cbp |= 1 << (5 - i);
01411             }
01412         }
01413 
01414         cbpc = cbp & 3;
01415         if (s->pict_type == FF_I_TYPE) {
01416             if(s->dquant) cbpc+=4;
01417             put_bits(&s->pb,
01418                 intra_MCBPC_bits[cbpc],
01419                 intra_MCBPC_code[cbpc]);
01420         } else {
01421             if(s->dquant) cbpc+=8;
01422             put_bits(&s->pb, 1, 0);     /* mb coded */
01423             put_bits(&s->pb,
01424                 inter_MCBPC_bits[cbpc + 4],
01425                 inter_MCBPC_code[cbpc + 4]);
01426         }
01427         if (s->h263_aic) {
01428             /* XXX: currently, we do not try to use ac prediction */
01429             put_bits(&s->pb, 1, 0);     /* no AC prediction */
01430         }
01431         cbpy = cbp >> 2;
01432         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01433         if(s->dquant)
01434             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01435 
01436         if(interleaved_stats){
01437             s->misc_bits+= get_bits_diff(s);
01438         }
01439     }
01440 
01441     for(i=0; i<6; i++) {
01442         /* encode each block */
01443         h263_encode_block(s, block[i], i);
01444 
01445         /* Update INTRADC for decoding */
01446         if (s->h263_aic && s->mb_intra) {
01447             block[i][0] = rec_intradc[i];
01448 
01449         }
01450     }
01451 
01452     if(interleaved_stats){
01453         if (!s->mb_intra) {
01454             s->p_tex_bits+= get_bits_diff(s);
01455             s->f_count++;
01456         }else{
01457             s->i_tex_bits+= get_bits_diff(s);
01458             s->i_count++;
01459         }
01460     }
01461 }
01462 #endif
01463 
01464 void ff_h263_loop_filter(MpegEncContext * s){
01465     int qp_c;
01466     const int linesize  = s->linesize;
01467     const int uvlinesize= s->uvlinesize;
01468     const int xy = s->mb_y * s->mb_stride + s->mb_x;
01469     uint8_t *dest_y = s->dest[0];
01470     uint8_t *dest_cb= s->dest[1];
01471     uint8_t *dest_cr= s->dest[2];
01472 
01473 //    if(s->pict_type==FF_B_TYPE && !s->readable) return;
01474 
01475     /*
01476        Diag Top
01477        Left Center
01478     */
01479     if(!IS_SKIP(s->current_picture.mb_type[xy])){
01480         qp_c= s->qscale;
01481         s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
01482         s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
01483     }else
01484         qp_c= 0;
01485 
01486     if(s->mb_y){
01487         int qp_dt, qp_tt, qp_tc;
01488 
01489         if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
01490             qp_tt=0;
01491         else
01492             qp_tt= s->current_picture.qscale_table[xy-s->mb_stride];
01493 
01494         if(qp_c)
01495             qp_tc= qp_c;
01496         else
01497             qp_tc= qp_tt;
01498 
01499         if(qp_tc){
01500             const int chroma_qp= s->chroma_qscale_table[qp_tc];
01501             s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
01502             s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
01503 
01504             s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
01505             s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
01506         }
01507 
01508         if(qp_tt)
01509             s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_tt);
01510 
01511         if(s->mb_x){
01512             if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
01513                 qp_dt= qp_tt;
01514             else
01515                 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
01516 
01517             if(qp_dt){
01518                 const int chroma_qp= s->chroma_qscale_table[qp_dt];
01519                 s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
01520                 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
01521                 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
01522             }
01523         }
01524     }
01525 
01526     if(qp_c){
01527         s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
01528         if(s->mb_y + 1 == s->mb_height)
01529             s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
01530     }
01531 
01532     if(s->mb_x){
01533         int qp_lc;
01534         if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
01535             qp_lc= qp_c;
01536         else
01537             qp_lc= s->current_picture.qscale_table[xy-1];
01538 
01539         if(qp_lc){
01540             s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
01541             if(s->mb_y + 1 == s->mb_height){
01542                 const int chroma_qp= s->chroma_qscale_table[qp_lc];
01543                 s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
01544                 s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
01545                 s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
01546             }
01547         }
01548     }
01549 }
01550 
01551 #if CONFIG_ENCODERS
01552 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
01553 {
01554     int x, y, wrap, a, c, pred_dc, scale;
01555     int16_t *dc_val;
01556 
01557     /* find prediction */
01558     if (n < 4) {
01559         x = 2 * s->mb_x + (n & 1);
01560         y = 2 * s->mb_y + ((n & 2) >> 1);
01561         wrap = s->b8_stride;
01562         dc_val = s->dc_val[0];
01563         scale = s->y_dc_scale;
01564     } else {
01565         x = s->mb_x;
01566         y = s->mb_y;
01567         wrap = s->mb_stride;
01568         dc_val = s->dc_val[n - 4 + 1];
01569         scale = s->c_dc_scale;
01570     }
01571     /* B C
01572      * A X
01573      */
01574     a = dc_val[(x - 1) + (y) * wrap];
01575     c = dc_val[(x) + (y - 1) * wrap];
01576 
01577     /* No prediction outside GOB boundary */
01578     if(s->first_slice_line && n!=3){
01579         if(n!=2) c= 1024;
01580         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
01581     }
01582     pred_dc = 1024;
01583     /* just DC prediction */
01584     if (a != 1024 && c != 1024)
01585         pred_dc = (a + c) >> 1;
01586     else if (a != 1024)
01587         pred_dc = a;
01588     else
01589         pred_dc = c;
01590 
01591     /* we assume pred is positive */
01592     //pred_dc = (pred_dc + (scale >> 1)) / scale;
01593     *dc_val_ptr = &dc_val[x + y * wrap];
01594     return pred_dc;
01595 }
01596 #endif /* CONFIG_ENCODERS */
01597 
01598 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
01599 {
01600     int x, y, wrap, a, c, pred_dc, scale, i;
01601     int16_t *dc_val, *ac_val, *ac_val1;
01602 
01603     /* find prediction */
01604     if (n < 4) {
01605         x = 2 * s->mb_x + (n & 1);
01606         y = 2 * s->mb_y + (n>> 1);
01607         wrap = s->b8_stride;
01608         dc_val = s->dc_val[0];
01609         ac_val = s->ac_val[0][0];
01610         scale = s->y_dc_scale;
01611     } else {
01612         x = s->mb_x;
01613         y = s->mb_y;
01614         wrap = s->mb_stride;
01615         dc_val = s->dc_val[n - 4 + 1];
01616         ac_val = s->ac_val[n - 4 + 1][0];
01617         scale = s->c_dc_scale;
01618     }
01619 
01620     ac_val += ((y) * wrap + (x)) * 16;
01621     ac_val1 = ac_val;
01622 
01623     /* B C
01624      * A X
01625      */
01626     a = dc_val[(x - 1) + (y) * wrap];
01627     c = dc_val[(x) + (y - 1) * wrap];
01628 
01629     /* No prediction outside GOB boundary */
01630     if(s->first_slice_line && n!=3){
01631         if(n!=2) c= 1024;
01632         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
01633     }
01634 
01635     if (s->ac_pred) {
01636         pred_dc = 1024;
01637         if (s->h263_aic_dir) {
01638             /* left prediction */
01639             if (a != 1024) {
01640                 ac_val -= 16;
01641                 for(i=1;i<8;i++) {
01642                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
01643                 }
01644                 pred_dc = a;
01645             }
01646         } else {
01647             /* top prediction */
01648             if (c != 1024) {
01649                 ac_val -= 16 * wrap;
01650                 for(i=1;i<8;i++) {
01651                     block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
01652                 }
01653                 pred_dc = c;
01654             }
01655         }
01656     } else {
01657         /* just DC prediction */
01658         if (a != 1024 && c != 1024)
01659             pred_dc = (a + c) >> 1;
01660         else if (a != 1024)
01661             pred_dc = a;
01662         else
01663             pred_dc = c;
01664     }
01665 
01666     /* we assume pred is positive */
01667     block[0]=block[0]*scale + pred_dc;
01668 
01669     if (block[0] < 0)
01670         block[0] = 0;
01671     else
01672         block[0] |= 1;
01673 
01674     /* Update AC/DC tables */
01675     dc_val[(x) + (y) * wrap] = block[0];
01676 
01677     /* left copy */
01678     for(i=1;i<8;i++)
01679         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
01680     /* top copy */
01681     for(i=1;i<8;i++)
01682         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
01683 }
01684 
01685 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
01686                         int *px, int *py)
01687 {
01688     int wrap;
01689     int16_t *A, *B, *C, (*mot_val)[2];
01690     static const int off[4]= {2, 1, 1, -1};
01691 
01692     wrap = s->b8_stride;
01693     mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
01694 
01695     A = mot_val[ - 1];
01696     /* special case for first (slice) line */
01697     if (s->first_slice_line && block<3) {
01698         // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
01699         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
01700         if(block==0){ //most common case
01701             if(s->mb_x  == s->resync_mb_x){ //rare
01702                 *px= *py = 0;
01703             }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
01704                 C = mot_val[off[block] - wrap];
01705                 if(s->mb_x==0){
01706                     *px = C[0];
01707                     *py = C[1];
01708                 }else{
01709                     *px = mid_pred(A[0], 0, C[0]);
01710                     *py = mid_pred(A[1], 0, C[1]);
01711                 }
01712             }else{
01713                 *px = A[0];
01714                 *py = A[1];
01715             }
01716         }else if(block==1){
01717             if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
01718                 C = mot_val[off[block] - wrap];
01719                 *px = mid_pred(A[0], 0, C[0]);
01720                 *py = mid_pred(A[1], 0, C[1]);
01721             }else{
01722                 *px = A[0];
01723                 *py = A[1];
01724             }
01725         }else{ /* block==2*/
01726             B = mot_val[ - wrap];
01727             C = mot_val[off[block] - wrap];
01728             if(s->mb_x == s->resync_mb_x) //rare
01729                 A[0]=A[1]=0;
01730 
01731             *px = mid_pred(A[0], B[0], C[0]);
01732             *py = mid_pred(A[1], B[1], C[1]);
01733         }
01734     } else {
01735         B = mot_val[ - wrap];
01736         C = mot_val[off[block] - wrap];
01737         *px = mid_pred(A[0], B[0], C[0]);
01738         *py = mid_pred(A[1], B[1], C[1]);
01739     }
01740     return *mot_val;
01741 }
01742 
01743 #if CONFIG_ENCODERS
01744 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
01745 {
01746     int range, l, bit_size, sign, code, bits;
01747 
01748     if (val == 0) {
01749         /* zero vector */
01750         code = 0;
01751         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
01752     } else {
01753         bit_size = f_code - 1;
01754         range = 1 << bit_size;
01755         /* modulo encoding */
01756         l= INT_BIT - 6 - bit_size;
01757         val = (val<<l)>>l;
01758         sign = val>>31;
01759         val= (val^sign)-sign;
01760         sign&=1;
01761 
01762         val--;
01763         code = (val >> bit_size) + 1;
01764         bits = val & (range - 1);
01765 
01766         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
01767         if (bit_size > 0) {
01768             put_bits(&s->pb, bit_size, bits);
01769         }
01770     }
01771 }
01772 
01773 /* Encode MV differences on H.263+ with Unrestricted MV mode */
01774 static void h263p_encode_umotion(MpegEncContext * s, int val)
01775 {
01776     short sval = 0;
01777     short i = 0;
01778     short n_bits = 0;
01779     short temp_val;
01780     int code = 0;
01781     int tcode;
01782 
01783     if ( val == 0)
01784         put_bits(&s->pb, 1, 1);
01785     else if (val == 1)
01786         put_bits(&s->pb, 3, 0);
01787     else if (val == -1)
01788         put_bits(&s->pb, 3, 2);
01789     else {
01790 
01791         sval = ((val < 0) ? (short)(-val):(short)val);
01792         temp_val = sval;
01793 
01794         while (temp_val != 0) {
01795             temp_val = temp_val >> 1;
01796             n_bits++;
01797         }
01798 
01799         i = n_bits - 1;
01800         while (i > 0) {
01801             tcode = (sval & (1 << (i-1))) >> (i-1);
01802             tcode = (tcode << 1) | 1;
01803             code = (code << 2) | tcode;
01804             i--;
01805         }
01806         code = ((code << 1) | (val < 0)) << 1;
01807         put_bits(&s->pb, (2*n_bits)+1, code);
01808         //printf("\nVal = %d\tCode = %d", sval, code);
01809     }
01810 }
01811 
01812 static void init_mv_penalty_and_fcode(MpegEncContext *s)
01813 {
01814     int f_code;
01815     int mv;
01816 
01817     for(f_code=1; f_code<=MAX_FCODE; f_code++){
01818         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
01819             int len;
01820 
01821             if(mv==0) len= mvtab[0][1];
01822             else{
01823                 int val, bit_size, range, code;
01824 
01825                 bit_size = f_code - 1;
01826                 range = 1 << bit_size;
01827 
01828                 val=mv;
01829                 if (val < 0)
01830                     val = -val;
01831                 val--;
01832                 code = (val >> bit_size) + 1;
01833                 if(code<33){
01834                     len= mvtab[code][1] + 1 + bit_size;
01835                 }else{
01836                     len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
01837                 }
01838             }
01839 
01840             mv_penalty[f_code][mv+MAX_MV]= len;
01841         }
01842     }
01843 
01844     for(f_code=MAX_FCODE; f_code>0; f_code--){
01845         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
01846             fcode_tab[mv+MAX_MV]= f_code;
01847         }
01848     }
01849 
01850     for(mv=0; mv<MAX_MV*2+1; mv++){
01851         umv_fcode_tab[mv]= 1;
01852     }
01853 }
01854 
01855 static void init_uni_dc_tab(void)
01856 {
01857     int level, uni_code, uni_len;
01858 
01859     for(level=-256; level<256; level++){
01860         int size, v, l;
01861         /* find number of bits */
01862         size = 0;
01863         v = abs(level);
01864         while (v) {
01865             v >>= 1;
01866             size++;
01867         }
01868 
01869         if (level < 0)
01870             l= (-level) ^ ((1 << size) - 1);
01871         else
01872             l= level;
01873 
01874         /* luminance */
01875         uni_code= DCtab_lum[size][0];
01876         uni_len = DCtab_lum[size][1];
01877 
01878         if (size > 0) {
01879             uni_code<<=size; uni_code|=l;
01880             uni_len+=size;
01881             if (size > 8){
01882                 uni_code<<=1; uni_code|=1;
01883                 uni_len++;
01884             }
01885         }
01886         uni_DCtab_lum_bits[level+256]= uni_code;
01887         uni_DCtab_lum_len [level+256]= uni_len;
01888 
01889         /* chrominance */
01890         uni_code= DCtab_chrom[size][0];
01891         uni_len = DCtab_chrom[size][1];
01892 
01893         if (size > 0) {
01894             uni_code<<=size; uni_code|=l;
01895             uni_len+=size;
01896             if (size > 8){
01897                 uni_code<<=1; uni_code|=1;
01898                 uni_len++;
01899             }
01900         }
01901         uni_DCtab_chrom_bits[level+256]= uni_code;
01902         uni_DCtab_chrom_len [level+256]= uni_len;
01903 
01904     }
01905 }
01906 
01907 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01908     int slevel, run, last;
01909 
01910     assert(MAX_LEVEL >= 64);
01911     assert(MAX_RUN   >= 63);
01912 
01913     for(slevel=-64; slevel<64; slevel++){
01914         if(slevel==0) continue;
01915         for(run=0; run<64; run++){
01916             for(last=0; last<=1; last++){
01917                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
01918                 int level= slevel < 0 ? -slevel : slevel;
01919                 int sign= slevel < 0 ? 1 : 0;
01920                 int bits, len, code;
01921                 int level1, run1;
01922 
01923                 len_tab[index]= 100;
01924 
01925                 /* ESC0 */
01926                 code= get_rl_index(rl, last, run, level);
01927                 bits= rl->table_vlc[code][0];
01928                 len=  rl->table_vlc[code][1];
01929                 bits=bits*2+sign; len++;
01930 
01931                 if(code!=rl->n && len < len_tab[index]){
01932                     bits_tab[index]= bits;
01933                     len_tab [index]= len;
01934                 }
01935 #if 1
01936                 /* ESC1 */
01937                 bits= rl->table_vlc[rl->n][0];
01938                 len=  rl->table_vlc[rl->n][1];
01939                 bits=bits*2;    len++; //esc1
01940                 level1= level - rl->max_level[last][run];
01941                 if(level1>0){
01942                     code= get_rl_index(rl, last, run, level1);
01943                     bits<<= rl->table_vlc[code][1];
01944                     len  += rl->table_vlc[code][1];
01945                     bits += rl->table_vlc[code][0];
01946                     bits=bits*2+sign; len++;
01947 
01948                     if(code!=rl->n && len < len_tab[index]){
01949                         bits_tab[index]= bits;
01950                         len_tab [index]= len;
01951                     }
01952                 }
01953 #endif
01954 #if 1
01955                 /* ESC2 */
01956                 bits= rl->table_vlc[rl->n][0];
01957                 len=  rl->table_vlc[rl->n][1];
01958                 bits=bits*4+2;    len+=2; //esc2
01959                 run1 = run - rl->max_run[last][level] - 1;
01960                 if(run1>=0){
01961                     code= get_rl_index(rl, last, run1, level);
01962                     bits<<= rl->table_vlc[code][1];
01963                     len  += rl->table_vlc[code][1];
01964                     bits += rl->table_vlc[code][0];
01965                     bits=bits*2+sign; len++;
01966 
01967                     if(code!=rl->n && len < len_tab[index]){
01968                         bits_tab[index]= bits;
01969                         len_tab [index]= len;
01970                     }
01971                 }
01972 #endif
01973                 /* ESC3 */
01974                 bits= rl->table_vlc[rl->n][0];
01975                 len = rl->table_vlc[rl->n][1];
01976                 bits=bits*4+3;    len+=2; //esc3
01977                 bits=bits*2+last; len++;
01978                 bits=bits*64+run; len+=6;
01979                 bits=bits*2+1;    len++;  //marker
01980                 bits=bits*4096+(slevel&0xfff); len+=12;
01981                 bits=bits*2+1;    len++;  //marker
01982 
01983                 if(len < len_tab[index]){
01984                     bits_tab[index]= bits;
01985                     len_tab [index]= len;
01986                 }
01987             }
01988         }
01989     }
01990 }
01991 
01992 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01993     int slevel, run, last;
01994 
01995     assert(MAX_LEVEL >= 64);
01996     assert(MAX_RUN   >= 63);
01997 
01998     for(slevel=-64; slevel<64; slevel++){
01999         if(slevel==0) continue;
02000         for(run=0; run<64; run++){
02001             for(last=0; last<=1; last++){
02002                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
02003                 int level= slevel < 0 ? -slevel : slevel;
02004                 int sign= slevel < 0 ? 1 : 0;
02005                 int bits, len, code;
02006 
02007                 len_tab[index]= 100;
02008 
02009                 /* ESC0 */
02010                 code= get_rl_index(rl, last, run, level);
02011                 bits= rl->table_vlc[code][0];
02012                 len=  rl->table_vlc[code][1];
02013                 bits=bits*2+sign; len++;
02014 
02015                 if(code!=rl->n && len < len_tab[index]){
02016                     if(bits_tab) bits_tab[index]= bits;
02017                     len_tab [index]= len;
02018                 }
02019                 /* ESC */
02020                 bits= rl->table_vlc[rl->n][0];
02021                 len = rl->table_vlc[rl->n][1];
02022                 bits=bits*2+last; len++;
02023                 bits=bits*64+run; len+=6;
02024                 bits=bits*256+(level&0xff); len+=8;
02025 
02026                 if(len < len_tab[index]){
02027                     if(bits_tab) bits_tab[index]= bits;
02028                     len_tab [index]= len;
02029                 }
02030             }
02031         }
02032     }
02033 }
02034 
02035 void h263_encode_init(MpegEncContext *s)
02036 {
02037     static int done = 0;
02038 
02039     if (!done) {
02040         done = 1;
02041 
02042         init_uni_dc_tab();
02043 
02044         init_rl(&rl_inter, static_rl_table_store[0]);
02045         init_rl(&rl_intra, static_rl_table_store[1]);
02046         init_rl(&rl_intra_aic, static_rl_table_store[2]);
02047 
02048         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
02049         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
02050 
02051         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
02052         init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
02053 
02054         init_mv_penalty_and_fcode(s);
02055     }
02056     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
02057 
02058     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
02059     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
02060     if(s->h263_aic){
02061         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
02062         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
02063     }
02064     s->ac_esc_length= 7+1+6+8;
02065 
02066     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
02067     switch(s->codec_id){
02068     case CODEC_ID_MPEG4:
02069         s->fcode_tab= fcode_tab;
02070         s->min_qcoeff= -2048;
02071         s->max_qcoeff=  2047;
02072         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
02073         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
02074         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
02075         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
02076         s->luma_dc_vlc_length= uni_DCtab_lum_len;
02077         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
02078         s->ac_esc_length= 7+2+1+6+1+12+1;
02079         s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
02080         s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
02081 
02082         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
02083 
02084             s->avctx->extradata= av_malloc(1024);
02085             init_put_bits(&s->pb, s->avctx->extradata, 1024);
02086 
02087             if(!(s->workaround_bugs & FF_BUG_MS))
02088                 mpeg4_encode_visual_object_header(s);
02089             mpeg4_encode_vol_header(s, 0, 0);
02090 
02091 //            ff_mpeg4_stuffing(&s->pb); ?
02092             flush_put_bits(&s->pb);
02093             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
02094         }
02095 
02096         break;
02097     case CODEC_ID_H263P:
02098         if(s->umvplus)
02099             s->fcode_tab= umv_fcode_tab;
02100         if(s->modified_quant){
02101             s->min_qcoeff= -2047;
02102             s->max_qcoeff=  2047;
02103         }else{
02104             s->min_qcoeff= -127;
02105             s->max_qcoeff=  127;
02106         }
02107         break;
02108         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
02109     case CODEC_ID_FLV1:
02110         if (s->h263_flv > 1) {
02111             s->min_qcoeff= -1023;
02112             s->max_qcoeff=  1023;
02113         } else {
02114             s->min_qcoeff= -127;
02115             s->max_qcoeff=  127;
02116         }
02117         s->y_dc_scale_table=
02118         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
02119         break;
02120     default: //nothing needed - default table already set in mpegvideo.c
02121         s->min_qcoeff= -127;
02122         s->max_qcoeff=  127;
02123         s->y_dc_scale_table=
02124         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
02125     }
02126 }
02127 
02133 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
02134 {
02135     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
02136     RLTable *rl;
02137 
02138     rl = &rl_inter;
02139     if (s->mb_intra && !s->h263_aic) {
02140         /* DC coef */
02141         level = block[0];
02142         /* 255 cannot be represented, so we clamp */
02143         if (level > 254) {
02144             level = 254;
02145             block[0] = 254;
02146         }
02147         /* 0 cannot be represented also */
02148         else if (level < 1) {
02149             level = 1;
02150             block[0] = 1;
02151         }
02152         if (level == 128) //FIXME check rv10
02153             put_bits(&s->pb, 8, 0xff);
02154         else
02155             put_bits(&s->pb, 8, level);
02156         i = 1;
02157     } else {
02158         i = 0;
02159         if (s->h263_aic && s->mb_intra)
02160             rl = &rl_intra_aic;
02161 
02162         if(s->alt_inter_vlc && !s->mb_intra){
02163             int aic_vlc_bits=0;
02164             int inter_vlc_bits=0;
02165             int wrong_pos=-1;
02166             int aic_code;
02167 
02168             last_index = s->block_last_index[n];
02169             last_non_zero = i - 1;
02170             for (; i <= last_index; i++) {
02171                 j = s->intra_scantable.permutated[i];
02172                 level = block[j];
02173                 if (level) {
02174                     run = i - last_non_zero - 1;
02175                     last = (i == last_index);
02176 
02177                     if(level<0) level= -level;
02178 
02179                     code = get_rl_index(rl, last, run, level);
02180                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
02181                     inter_vlc_bits += rl->table_vlc[code][1]+1;
02182                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
02183 
02184                     if (code == rl->n) {
02185                         inter_vlc_bits += 1+6+8-1;
02186                     }
02187                     if (aic_code == rl_intra_aic.n) {
02188                         aic_vlc_bits += 1+6+8-1;
02189                         wrong_pos += run + 1;
02190                     }else
02191                         wrong_pos += wrong_run[aic_code];
02192                     last_non_zero = i;
02193                 }
02194             }
02195             i = 0;
02196             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
02197                 rl = &rl_intra_aic;
02198         }
02199     }
02200 
02201     /* AC coefs */
02202     last_index = s->block_last_index[n];
02203     last_non_zero = i - 1;
02204     for (; i <= last_index; i++) {
02205         j = s->intra_scantable.permutated[i];
02206         level = block[j];
02207         if (level) {
02208             run = i - last_non_zero - 1;
02209             last = (i == last_index);
02210             sign = 0;
02211             slevel = level;
02212             if (level < 0) {
02213                 sign = 1;
02214                 level = -level;
02215             }
02216             code = get_rl_index(rl, last, run, level);
02217             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02218             if (code == rl->n) {
02219               if(s->h263_flv <= 1){
02220                 put_bits(&s->pb, 1, last);
02221                 put_bits(&s->pb, 6, run);
02222 
02223                 assert(slevel != 0);
02224 
02225                 if(level < 128)
02226                     put_sbits(&s->pb, 8, slevel);
02227                 else{
02228                     put_bits(&s->pb, 8, 128);
02229                     put_sbits(&s->pb, 5, slevel);
02230                     put_sbits(&s->pb, 6, slevel>>5);
02231                 }
02232               }else{
02233                 if(level < 64) { // 7-bit level
02234                         put_bits(&s->pb, 1, 0);
02235                         put_bits(&s->pb, 1, last);
02236                         put_bits(&s->pb, 6, run);
02237 
02238                         put_sbits(&s->pb, 7, slevel);
02239                     } else {
02240                         /* 11-bit level */
02241                         put_bits(&s->pb, 1, 1);
02242                         put_bits(&s->pb, 1, last);
02243                         put_bits(&s->pb, 6, run);
02244 
02245                         put_sbits(&s->pb, 11, slevel);
02246                     }
02247               }
02248             } else {
02249                 put_bits(&s->pb, 1, sign);
02250             }
02251             last_non_zero = i;
02252         }
02253     }
02254 }
02255 
02256 /***************************************************/
02260 void ff_mpeg4_stuffing(PutBitContext * pbc)
02261 {
02262     int length;
02263     put_bits(pbc, 1, 0);
02264     length= (-put_bits_count(pbc))&7;
02265     if(length) put_bits(pbc, length, (1<<length)-1);
02266 }
02267 
02268 /* must be called before writing the header */
02269 void ff_set_mpeg4_time(MpegEncContext * s){
02270     if(s->pict_type==FF_B_TYPE){
02271         ff_mpeg4_init_direct_mv(s);
02272     }else{
02273         s->last_time_base= s->time_base;
02274         s->time_base= s->time/s->avctx->time_base.den;
02275     }
02276 }
02277 
02278 static void mpeg4_encode_gop_header(MpegEncContext * s){
02279     int hours, minutes, seconds;
02280     int64_t time;
02281 
02282     put_bits(&s->pb, 16, 0);
02283     put_bits(&s->pb, 16, GOP_STARTCODE);
02284 
02285     time= s->current_picture_ptr->pts;
02286     if(s->reordered_input_picture[1])
02287         time= FFMIN(time, s->reordered_input_picture[1]->pts);
02288     time= time*s->avctx->time_base.num;
02289 
02290     seconds= time/s->avctx->time_base.den;
02291     minutes= seconds/60; seconds %= 60;
02292     hours= minutes/60; minutes %= 60;
02293     hours%=24;
02294 
02295     put_bits(&s->pb, 5, hours);
02296     put_bits(&s->pb, 6, minutes);
02297     put_bits(&s->pb, 1, 1);
02298     put_bits(&s->pb, 6, seconds);
02299 
02300     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
02301     put_bits(&s->pb, 1, 0); //broken link == NO
02302 
02303     s->last_time_base= time / s->avctx->time_base.den;
02304 
02305     ff_mpeg4_stuffing(&s->pb);
02306 }
02307 
02308 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
02309     int profile_and_level_indication;
02310     int vo_ver_id;
02311 
02312     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
02313         profile_and_level_indication = s->avctx->profile << 4;
02314     }else if(s->max_b_frames || s->quarter_sample){
02315         profile_and_level_indication= 0xF0; // adv simple
02316     }else{
02317         profile_and_level_indication= 0x00; // simple
02318     }
02319 
02320     if(s->avctx->level != FF_LEVEL_UNKNOWN){
02321         profile_and_level_indication |= s->avctx->level;
02322     }else{
02323         profile_and_level_indication |= 1; //level 1
02324     }
02325 
02326     if(profile_and_level_indication>>4 == 0xF){
02327         vo_ver_id= 5;
02328     }else{
02329         vo_ver_id= 1;
02330     }
02331 
02332     //FIXME levels
02333 
02334     put_bits(&s->pb, 16, 0);
02335     put_bits(&s->pb, 16, VOS_STARTCODE);
02336 
02337     put_bits(&s->pb, 8, profile_and_level_indication);
02338 
02339     put_bits(&s->pb, 16, 0);
02340     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
02341 
02342     put_bits(&s->pb, 1, 1);
02343         put_bits(&s->pb, 4, vo_ver_id);
02344         put_bits(&s->pb, 3, 1); //priority
02345 
02346     put_bits(&s->pb, 4, 1); //visual obj type== video obj
02347 
02348     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
02349 
02350     ff_mpeg4_stuffing(&s->pb);
02351 }
02352 
02353 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
02354 {
02355     int vo_ver_id;
02356 
02357     if (!CONFIG_MPEG4_ENCODER)  return;
02358 
02359     if(s->max_b_frames || s->quarter_sample){
02360         vo_ver_id= 5;
02361         s->vo_type= ADV_SIMPLE_VO_TYPE;
02362     }else{
02363         vo_ver_id= 1;
02364         s->vo_type= SIMPLE_VO_TYPE;
02365     }
02366 
02367     put_bits(&s->pb, 16, 0);
02368     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
02369     put_bits(&s->pb, 16, 0);
02370     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
02371 
02372     put_bits(&s->pb, 1, 0);             /* random access vol */
02373     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
02374     if(s->workaround_bugs & FF_BUG_MS) {
02375         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
02376     } else {
02377         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
02378         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
02379         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
02380     }
02381 
02382     aspect_to_info(s, s->avctx->sample_aspect_ratio);
02383 
02384     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
02385     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
02386         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
02387         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
02388     }
02389 
02390     if(s->workaround_bugs & FF_BUG_MS) { //
02391         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
02392     } else {
02393         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
02394         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
02395         put_bits(&s->pb, 1, s->low_delay);
02396         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
02397     }
02398 
02399     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
02400     put_bits(&s->pb, 1, 1);             /* marker bit */
02401 
02402     put_bits(&s->pb, 16, s->avctx->time_base.den);
02403     if (s->time_increment_bits < 1)
02404         s->time_increment_bits = 1;
02405     put_bits(&s->pb, 1, 1);             /* marker bit */
02406     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
02407     put_bits(&s->pb, 1, 1);             /* marker bit */
02408     put_bits(&s->pb, 13, s->width);     /* vol width */
02409     put_bits(&s->pb, 1, 1);             /* marker bit */
02410     put_bits(&s->pb, 13, s->height);    /* vol height */
02411     put_bits(&s->pb, 1, 1);             /* marker bit */
02412     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
02413     put_bits(&s->pb, 1, 1);             /* obmc disable */
02414     if (vo_ver_id == 1) {
02415         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
02416     }else{
02417         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
02418     }
02419 
02420     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
02421     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
02422 
02423     if(s->mpeg_quant){
02424         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
02425         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
02426     }
02427 
02428     if (vo_ver_id != 1)
02429         put_bits(&s->pb, 1, s->quarter_sample);
02430     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
02431     s->resync_marker= s->rtp_mode;
02432     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
02433     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
02434     if(s->data_partitioning){
02435         put_bits(&s->pb, 1, 0);         /* no rvlc */
02436     }
02437 
02438     if (vo_ver_id != 1){
02439         put_bits(&s->pb, 1, 0);         /* newpred */
02440         put_bits(&s->pb, 1, 0);         /* reduced res vop */
02441     }
02442     put_bits(&s->pb, 1, 0);             /* scalability */
02443 
02444     ff_mpeg4_stuffing(&s->pb);
02445 
02446     /* user data */
02447     if(!(s->flags & CODEC_FLAG_BITEXACT)){
02448         put_bits(&s->pb, 16, 0);
02449         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
02450         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
02451     }
02452 }
02453 
02454 /* write mpeg4 VOP header */
02455 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
02456 {
02457     int time_incr;
02458     int time_div, time_mod;
02459 
02460     if(s->pict_type==FF_I_TYPE){
02461         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
02462             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
02463                 mpeg4_encode_visual_object_header(s);
02464             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
02465                 mpeg4_encode_vol_header(s, 0, 0);
02466         }
02467         if(!(s->workaround_bugs & FF_BUG_MS))
02468             mpeg4_encode_gop_header(s);
02469     }
02470 
02471     s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
02472 
02473 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
02474 
02475     put_bits(&s->pb, 16, 0);                /* vop header */
02476     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
02477     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
02478 
02479     assert(s->time>=0);
02480     time_div= s->time/s->avctx->time_base.den;
02481     time_mod= s->time%s->avctx->time_base.den;
02482     time_incr= time_div - s->last_time_base;
02483     assert(time_incr >= 0);
02484     while(time_incr--)
02485         put_bits(&s->pb, 1, 1);
02486 
02487     put_bits(&s->pb, 1, 0);
02488 
02489     put_bits(&s->pb, 1, 1);                             /* marker */
02490     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
02491     put_bits(&s->pb, 1, 1);                             /* marker */
02492     put_bits(&s->pb, 1, 1);                             /* vop coded */
02493     if (    s->pict_type == FF_P_TYPE
02494         || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
02495         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
02496     }
02497     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
02498     if(!s->progressive_sequence){
02499          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
02500          put_bits(&s->pb, 1, s->alternate_scan);
02501     }
02502     //FIXME sprite stuff
02503 
02504     put_bits(&s->pb, 5, s->qscale);
02505 
02506     if (s->pict_type != FF_I_TYPE)
02507         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
02508     if (s->pict_type == FF_B_TYPE)
02509         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
02510     //    printf("****frame %d\n", picture_number);
02511 }
02512 
02513 #endif //CONFIG_ENCODERS
02514 
02522 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
02523 {
02524     int a, b, c, wrap, pred, scale, ret;
02525     int16_t *dc_val;
02526 
02527     /* find prediction */
02528     if (n < 4) {
02529         scale = s->y_dc_scale;
02530     } else {
02531         scale = s->c_dc_scale;
02532     }
02533     if(IS_3IV1)
02534         scale= 8;
02535 
02536     wrap= s->block_wrap[n];
02537     dc_val = s->dc_val[0] + s->block_index[n];
02538 
02539     /* B C
02540      * A X
02541      */
02542     a = dc_val[ - 1];
02543     b = dc_val[ - 1 - wrap];
02544     c = dc_val[ - wrap];
02545 
02546     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
02547     if(s->first_slice_line && n!=3){
02548         if(n!=2) b=c= 1024;
02549         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
02550     }
02551     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
02552         if(n==0 || n==4 || n==5)
02553             b=1024;
02554     }
02555 
02556     if (abs(a - b) < abs(b - c)) {
02557         pred = c;
02558         *dir_ptr = 1; /* top */
02559     } else {
02560         pred = a;
02561         *dir_ptr = 0; /* left */
02562     }
02563     /* we assume pred is positive */
02564     pred = FASTDIV((pred + (scale >> 1)), scale);
02565 
02566     if(encoding){
02567         ret = level - pred;
02568     }else{
02569         level += pred;
02570         ret= level;
02571         if(s->error_recognition>=3){
02572             if(level<0){
02573                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
02574                 return -1;
02575             }
02576             if(level*scale > 2048 + scale){
02577                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
02578                 return -1;
02579             }
02580         }
02581     }
02582     level *=scale;
02583     if(level&(~2047)){
02584         if(level<0)
02585             level=0;
02586         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
02587             level=2047;
02588     }
02589     dc_val[0]= level;
02590 
02591     return ret;
02592 }
02593 
02599 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
02600                    int dir)
02601 {
02602     int i;
02603     int16_t *ac_val, *ac_val1;
02604     int8_t * const qscale_table= s->current_picture.qscale_table;
02605 
02606     /* find prediction */
02607     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02608     ac_val1 = ac_val;
02609     if (s->ac_pred) {
02610         if (dir == 0) {
02611             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
02612             /* left prediction */
02613             ac_val -= 16;
02614 
02615             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
02616                 /* same qscale */
02617                 for(i=1;i<8;i++) {
02618                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
02619                 }
02620             }else{
02621                 /* different qscale, we must rescale */
02622                 for(i=1;i<8;i++) {
02623                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
02624                 }
02625             }
02626         } else {
02627             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
02628             /* top prediction */
02629             ac_val -= 16 * s->block_wrap[n];
02630 
02631             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
02632                 /* same qscale */
02633                 for(i=1;i<8;i++) {
02634                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
02635                 }
02636             }else{
02637                 /* different qscale, we must rescale */
02638                 for(i=1;i<8;i++) {
02639                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
02640                 }
02641             }
02642         }
02643     }
02644     /* left copy */
02645     for(i=1;i<8;i++)
02646         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
02647 
02648     /* top copy */
02649     for(i=1;i<8;i++)
02650         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
02651 
02652 }
02653 
02654 #if CONFIG_ENCODERS
02655 
02660 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
02661 {
02662 #if 1
02663 //    if(level<-255 || level>255) printf("dc overflow\n");
02664     level+=256;
02665     if (n < 4) {
02666         /* luminance */
02667         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
02668     } else {
02669         /* chrominance */
02670         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
02671     }
02672 #else
02673     int size, v;
02674     /* find number of bits */
02675     size = 0;
02676     v = abs(level);
02677     while (v) {
02678         v >>= 1;
02679         size++;
02680     }
02681 
02682     if (n < 4) {
02683         /* luminance */
02684         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
02685     } else {
02686         /* chrominance */
02687         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
02688     }
02689 
02690     /* encode remaining bits */
02691     if (size > 0) {
02692         if (level < 0)
02693             level = (-level) ^ ((1 << size) - 1);
02694         put_bits(&s->pb, size, level);
02695         if (size > 8)
02696             put_bits(&s->pb, 1, 1);
02697     }
02698 #endif
02699 }
02700 
02701 static inline int mpeg4_get_dc_length(int level, int n){
02702     if (n < 4) {
02703         return uni_DCtab_lum_len[level + 256];
02704     } else {
02705         return uni_DCtab_chrom_len[level + 256];
02706     }
02707 }
02708 
02713 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
02714                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
02715 {
02716     int i, last_non_zero;
02717 #if 0 //variables for the outcommented version
02718     int code, sign, last;
02719 #endif
02720     const RLTable *rl;
02721     uint32_t *bits_tab;
02722     uint8_t *len_tab;
02723     const int last_index = s->block_last_index[n];
02724 
02725     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
02726         /* mpeg4 based DC predictor */
02727         mpeg4_encode_dc(dc_pb, intra_dc, n);
02728         if(last_index<1) return;
02729         i = 1;
02730         rl = &rl_intra;
02731         bits_tab= uni_mpeg4_intra_rl_bits;
02732         len_tab = uni_mpeg4_intra_rl_len;
02733     } else {
02734         if(last_index<0) return;
02735         i = 0;
02736         rl = &rl_inter;
02737         bits_tab= uni_mpeg4_inter_rl_bits;
02738         len_tab = uni_mpeg4_inter_rl_len;
02739     }
02740 
02741     /* AC coefs */
02742     last_non_zero = i - 1;
02743 #if 1
02744     for (; i < last_index; i++) {
02745         int level = block[ scan_table[i] ];
02746         if (level) {
02747             int run = i - last_non_zero - 1;
02748             level+=64;
02749             if((level&(~127)) == 0){
02750                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
02751                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
02752             }else{ //ESC3
02753                 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);
02754             }
02755             last_non_zero = i;
02756         }
02757     }
02758     /*if(i<=last_index)*/{
02759         int level = block[ scan_table[i] ];
02760         int run = i - last_non_zero - 1;
02761         level+=64;
02762         if((level&(~127)) == 0){
02763             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
02764             put_bits(ac_pb, len_tab[index], bits_tab[index]);
02765         }else{ //ESC3
02766             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);
02767         }
02768     }
02769 #else
02770     for (; i <= last_index; i++) {
02771         const int slevel = block[ scan_table[i] ];
02772         if (slevel) {
02773             int level;
02774             int run = i - last_non_zero - 1;
02775             last = (i == last_index);
02776             sign = 0;
02777             level = slevel;
02778             if (level < 0) {
02779                 sign = 1;
02780                 level = -level;
02781             }
02782             code = get_rl_index(rl, last, run, level);
02783             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02784             if (code == rl->n) {
02785                 int level1, run1;
02786                 level1 = level - rl->max_level[last][run];
02787                 if (level1 < 1)
02788                     goto esc2;
02789                 code = get_rl_index(rl, last, run, level1);
02790                 if (code == rl->n) {
02791                 esc2:
02792                     put_bits(ac_pb, 1, 1);
02793                     if (level > MAX_LEVEL)
02794                         goto esc3;
02795                     run1 = run - rl->max_run[last][level] - 1;
02796                     if (run1 < 0)
02797                         goto esc3;
02798                     code = get_rl_index(rl, last, run1, level);
02799                     if (code == rl->n) {
02800                     esc3:
02801                         /* third escape */
02802                         put_bits(ac_pb, 1, 1);
02803                         put_bits(ac_pb, 1, last);
02804                         put_bits(ac_pb, 6, run);
02805                         put_bits(ac_pb, 1, 1);
02806                         put_sbits(ac_pb, 12, slevel);
02807                         put_bits(ac_pb, 1, 1);
02808                     } else {
02809                         /* second escape */
02810                         put_bits(ac_pb, 1, 0);
02811                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02812                         put_bits(ac_pb, 1, sign);
02813                     }
02814                 } else {
02815                     /* first escape */
02816                     put_bits(ac_pb, 1, 0);
02817                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02818                     put_bits(ac_pb, 1, sign);
02819                 }
02820             } else {
02821                 put_bits(ac_pb, 1, sign);
02822             }
02823             last_non_zero = i;
02824         }
02825     }
02826 #endif
02827 }
02828 
02829 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
02830                                uint8_t *scan_table)
02831 {
02832     int i, last_non_zero;
02833     const RLTable *rl;
02834     uint8_t *len_tab;
02835     const int last_index = s->block_last_index[n];
02836     int len=0;
02837 
02838     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
02839         /* mpeg4 based DC predictor */
02840         len += mpeg4_get_dc_length(intra_dc, n);
02841         if(last_index<1) return len;
02842         i = 1;
02843         rl = &rl_intra;
02844         len_tab = uni_mpeg4_intra_rl_len;
02845     } else {
02846         if(last_index<0) return 0;
02847         i = 0;
02848         rl = &rl_inter;
02849         len_tab = uni_mpeg4_inter_rl_len;
02850     }
02851 
02852     /* AC coefs */
02853     last_non_zero = i - 1;
02854     for (; i < last_index; i++) {
02855         int level = block[ scan_table[i] ];
02856         if (level) {
02857             int run = i - last_non_zero - 1;
02858             level+=64;
02859             if((level&(~127)) == 0){
02860                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
02861                 len += len_tab[index];
02862             }else{ //ESC3
02863                 len += 7+2+1+6+1+12+1;
02864             }
02865             last_non_zero = i;
02866         }
02867     }
02868     /*if(i<=last_index)*/{
02869         int level = block[ scan_table[i] ];
02870         int run = i - last_non_zero - 1;
02871         level+=64;
02872         if((level&(~127)) == 0){
02873             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
02874             len += len_tab[index];
02875         }else{ //ESC3
02876             len += 7+2+1+6+1+12+1;
02877         }
02878     }
02879 
02880     return len;
02881 }
02882 
02883 #endif
02884 
02885 
02886 /***********************************************/
02887 /* decoding */
02888 
02889 static VLC intra_MCBPC_vlc;
02890 static VLC inter_MCBPC_vlc;
02891 static VLC cbpy_vlc;
02892 static VLC mv_vlc;
02893 static VLC dc_lum, dc_chrom;
02894 static VLC sprite_trajectory;
02895 static VLC mb_type_b_vlc;
02896 static VLC h263_mbtype_b_vlc;
02897 static VLC cbpc_b_vlc;
02898 
02899 /* init vlcs */
02900 
02901 /* XXX: find a better solution to handle static init */
02902 void h263_decode_init_vlc(MpegEncContext *s)
02903 {
02904     static int done = 0;
02905 
02906     if (!done) {
02907         done = 1;
02908 
02909         INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
02910                  intra_MCBPC_bits, 1, 1,
02911                  intra_MCBPC_code, 1, 1, 72);
02912         INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
02913                  inter_MCBPC_bits, 1, 1,
02914                  inter_MCBPC_code, 1, 1, 198);
02915         INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
02916                  &cbpy_tab[0][1], 2, 1,
02917                  &cbpy_tab[0][0], 2, 1, 64);
02918         INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
02919                  &mvtab[0][1], 2, 1,
02920                  &mvtab[0][0], 2, 1, 538);
02921         init_rl(&rl_inter, static_rl_table_store[0]);
02922         init_rl(&rl_intra, static_rl_table_store[1]);
02923         init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
02924         init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
02925         init_rl(&rl_intra_aic, static_rl_table_store[2]);
02926         INIT_VLC_RL(rl_inter, 554);
02927         INIT_VLC_RL(rl_intra, 554);
02928         INIT_VLC_RL(rvlc_rl_inter, 1072);
02929         INIT_VLC_RL(rvlc_rl_intra, 1072);
02930         INIT_VLC_RL(rl_intra_aic, 554);
02931         INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
02932                  &DCtab_lum[0][1], 2, 1,
02933                  &DCtab_lum[0][0], 2, 1, 512);
02934         INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
02935                  &DCtab_chrom[0][1], 2, 1,
02936                  &DCtab_chrom[0][0], 2, 1, 512);
02937         INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
02938                  &sprite_trajectory_tab[0][1], 4, 2,
02939                  &sprite_trajectory_tab[0][0], 4, 2, 128);
02940         INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
02941                  &mb_type_b_tab[0][1], 2, 1,
02942                  &mb_type_b_tab[0][0], 2, 1, 16);
02943         INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
02944                  &h263_mbtype_b_tab[0][1], 2, 1,
02945                  &h263_mbtype_b_tab[0][0], 2, 1, 80);
02946         INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
02947                  &cbpc_b_tab[0][1], 2, 1,
02948                  &cbpc_b_tab[0][0], 2, 1, 8);
02949     }
02950 }
02951 
02955 int ff_h263_get_gob_height(MpegEncContext *s){
02956     if (s->height <= 400)
02957         return 1;
02958     else if (s->height <= 800)
02959         return  2;
02960     else
02961         return 4;
02962 }
02963 
02964 int ff_h263_decode_mba(MpegEncContext *s)
02965 {
02966     int i, mb_pos;
02967 
02968     for(i=0; i<6; i++){
02969         if(s->mb_num-1 <= ff_mba_max[i]) break;
02970     }
02971     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
02972     s->mb_x= mb_pos % s->mb_width;
02973     s->mb_y= mb_pos / s->mb_width;
02974 
02975     return mb_pos;
02976 }
02977 
02978 void ff_h263_encode_mba(MpegEncContext *s)
02979 {
02980     int i, mb_pos;
02981 
02982     for(i=0; i<6; i++){
02983         if(s->mb_num-1 <= ff_mba_max[i]) break;
02984     }
02985     mb_pos= s->mb_x + s->mb_width*s->mb_y;
02986     put_bits(&s->pb, ff_mba_length[i], mb_pos);
02987 }
02988 
02993 static int h263_decode_gob_header(MpegEncContext *s)
02994 {
02995     unsigned int val, gfid, gob_number;
02996     int left;
02997 
02998     /* Check for GOB Start Code */
02999     val = show_bits(&s->gb, 16);
03000     if(val)
03001         return -1;
03002 
03003         /* We have a GBSC probably with GSTUFF */
03004     skip_bits(&s->gb, 16); /* Drop the zeros */
03005     left= s->gb.size_in_bits - get_bits_count(&s->gb);
03006     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
03007     for(;left>13; left--){
03008         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
03009     }
03010     if(left<=13)
03011         return -1;
03012 
03013     if(s->h263_slice_structured){
03014         if(get_bits1(&s->gb)==0)
03015             return -1;
03016 
03017         ff_h263_decode_mba(s);
03018 
03019         if(s->mb_num > 1583)
03020             if(get_bits1(&s->gb)==0)
03021                 return -1;
03022 
03023         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
03024         if(get_bits1(&s->gb)==0)
03025             return -1;
03026         gfid = get_bits(&s->gb, 2); /* GFID */
03027     }else{
03028         gob_number = get_bits(&s->gb, 5); /* GN */
03029         s->mb_x= 0;
03030         s->mb_y= s->gob_index* gob_number;
03031         gfid = get_bits(&s->gb, 2); /* GFID */
03032         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
03033     }
03034 
03035     if(s->mb_y >= s->mb_height)
03036         return -1;
03037 
03038     if(s->qscale==0)
03039         return -1;
03040 
03041     return 0;
03042 }
03043 
03044 static inline void memsetw(short *tab, int val, int n)
03045 {
03046     int i;
03047     for(i=0;i<n;i++)
03048         tab[i] = val;
03049 }
03050 
03051 #if CONFIG_ENCODERS
03052 
03053 void ff_mpeg4_init_partitions(MpegEncContext *s)
03054 {
03055     uint8_t *start= pbBufPtr(&s->pb);
03056     uint8_t *end= s->pb.buf_end;
03057     int size= end - start;
03058     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
03059     int tex_size= (size - 2*pb_size)&(~3);
03060 
03061     set_put_bits_buffer_size(&s->pb, pb_size);
03062     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
03063     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
03064 }
03065 
03066 void ff_mpeg4_merge_partitions(MpegEncContext *s)
03067 {
03068     const int pb2_len   = put_bits_count(&s->pb2   );
03069     const int tex_pb_len= put_bits_count(&s->tex_pb);
03070     const int bits= put_bits_count(&s->pb);
03071 
03072     if(s->pict_type==FF_I_TYPE){
03073         put_bits(&s->pb, 19, DC_MARKER);
03074         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
03075         s->i_tex_bits+= tex_pb_len;
03076     }else{
03077         put_bits(&s->pb, 17, MOTION_MARKER);
03078         s->misc_bits+=17 + pb2_len;
03079         s->mv_bits+= bits - s->last_bits;
03080         s->p_tex_bits+= tex_pb_len;
03081     }
03082 
03083     flush_put_bits(&s->pb2);
03084     flush_put_bits(&s->tex_pb);
03085 
03086     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
03087     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
03088     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
03089     s->last_bits= put_bits_count(&s->pb);
03090 }
03091 
03092 #endif //CONFIG_ENCODERS
03093 
03094 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
03095     switch(s->pict_type){
03096         case FF_I_TYPE:
03097             return 16;
03098         case FF_P_TYPE:
03099         case FF_S_TYPE:
03100             return s->f_code+15;
03101         case FF_B_TYPE:
03102             return FFMAX3(s->f_code, s->b_code, 2) + 15;
03103         default:
03104             return -1;
03105     }
03106 }
03107 
03108 #if CONFIG_ENCODERS
03109 
03110 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
03111 {
03112     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
03113 
03114     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
03115     put_bits(&s->pb, 1, 1);
03116 
03117     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
03118     put_bits(&s->pb, s->quant_precision, s->qscale);
03119     put_bits(&s->pb, 1, 0); /* no HEC */
03120 }
03121 
03122 #endif //CONFIG_ENCODERS
03123 
03128 static inline int mpeg4_is_resync(MpegEncContext *s){
03129     int bits_count= get_bits_count(&s->gb);
03130     int v= show_bits(&s->gb, 16);
03131 
03132     if(s->workaround_bugs&FF_BUG_NO_PADDING){
03133         return 0;
03134     }
03135 
03136     while(v<=0xFF){
03137         if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
03138             break;
03139         skip_bits(&s->gb, 8+s->pict_type);
03140         bits_count+= 8+s->pict_type;
03141         v= show_bits(&s->gb, 16);
03142     }
03143 
03144     if(bits_count + 8 >= s->gb.size_in_bits){
03145         v>>=8;
03146         v|= 0x7F >> (7-(bits_count&7));
03147 
03148         if(v==0x7F)
03149             return 1;
03150     }else{
03151         if(v == ff_mpeg4_resync_prefix[bits_count&7]){
03152             int len;
03153             GetBitContext gb= s->gb;
03154 
03155             skip_bits(&s->gb, 1);
03156             align_get_bits(&s->gb);
03157 
03158             for(len=0; len<32; len++){
03159                 if(get_bits1(&s->gb)) break;
03160             }
03161 
03162             s->gb= gb;
03163 
03164             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
03165                 return 1;
03166         }
03167     }
03168     return 0;
03169 }
03170 
03175 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
03176 {
03177     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
03178     int header_extension=0, mb_num, len;
03179 
03180     /* is there enough space left for a video packet + header */
03181     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
03182 
03183     for(len=0; len<32; len++){
03184         if(get_bits1(&s->gb)) break;
03185     }
03186 
03187     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
03188         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
03189         return -1;
03190     }
03191 
03192     if(s->shape != RECT_SHAPE){
03193         header_extension= get_bits1(&s->gb);
03194         //FIXME more stuff here
03195     }
03196 
03197     mb_num= get_bits(&s->gb, mb_num_bits);
03198     if(mb_num>=s->mb_num){
03199         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
03200         return -1;
03201     }
03202     if(s->pict_type == FF_B_TYPE){
03203         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
03204         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
03205     }
03206 
03207     s->mb_x= mb_num % s->mb_width;
03208     s->mb_y= mb_num / s->mb_width;
03209 
03210     if(s->shape != BIN_ONLY_SHAPE){
03211         int qscale= get_bits(&s->gb, s->quant_precision);
03212         if(qscale)
03213             s->chroma_qscale=s->qscale= qscale;
03214     }
03215 
03216     if(s->shape == RECT_SHAPE){
03217         header_extension= get_bits1(&s->gb);
03218     }
03219     if(header_extension){
03220         int time_increment;
03221         int time_incr=0;
03222 
03223         while (get_bits1(&s->gb) != 0)
03224             time_incr++;
03225 
03226         check_marker(&s->gb, "before time_increment in video packed header");
03227         time_increment= get_bits(&s->gb, s->time_increment_bits);
03228         check_marker(&s->gb, "before vop_coding_type in video packed header");
03229 
03230         skip_bits(&s->gb, 2); /* vop coding type */
03231         //FIXME not rect stuff here
03232 
03233         if(s->shape != BIN_ONLY_SHAPE){
03234             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
03235 //FIXME don't just ignore everything
03236             if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03237                 mpeg4_decode_sprite_trajectory(s, &s->gb);
03238                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
03239             }
03240 
03241             //FIXME reduced res stuff here
03242 
03243             if (s->pict_type != FF_I_TYPE) {
03244                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
03245                 if(f_code==0){
03246                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
03247                 }
03248             }
03249             if (s->pict_type == FF_B_TYPE) {
03250                 int b_code = get_bits(&s->gb, 3);
03251                 if(b_code==0){
03252                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
03253                 }
03254             }
03255         }
03256     }
03257     //FIXME new-pred stuff
03258 
03259 //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));
03260 
03261     return 0;
03262 }
03263 
03264 void ff_mpeg4_clean_buffers(MpegEncContext *s)
03265 {
03266     int c_wrap, c_xy, l_wrap, l_xy;
03267 
03268     l_wrap= s->b8_stride;
03269     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
03270     c_wrap= s->mb_stride;
03271     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
03272 
03273 #if 0
03274     /* clean DC */
03275     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
03276     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
03277     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
03278 #endif
03279 
03280     /* clean AC */
03281     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
03282     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
03283     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
03284 
03285     /* clean MV */
03286     // we can't clear the MVs as they might be needed by a b frame
03287 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
03288 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
03289     s->last_mv[0][0][0]=
03290     s->last_mv[0][0][1]=
03291     s->last_mv[1][0][0]=
03292     s->last_mv[1][0][1]= 0;
03293 }
03294 
03301 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
03302 {
03303     assert(p < end);
03304 
03305     end-=2;
03306     p++;
03307     for(;p<end; p+=2){
03308         if(!*p){
03309             if     (!p[-1] && p[1]) return p - 1;
03310             else if(!p[ 1] && p[2]) return p;
03311         }
03312     }
03313     return end+2;
03314 }
03315 
03320 int ff_h263_resync(MpegEncContext *s){
03321     int left, pos, ret;
03322 
03323     if(s->codec_id==CODEC_ID_MPEG4){
03324         skip_bits1(&s->gb);
03325         align_get_bits(&s->gb);
03326     }
03327 
03328     if(show_bits(&s->gb, 16)==0){
03329         pos= get_bits_count(&s->gb);
03330         if(s->codec_id==CODEC_ID_MPEG4)
03331             ret= mpeg4_decode_video_packet_header(s);
03332         else
03333             ret= h263_decode_gob_header(s);
03334         if(ret>=0)
03335             return pos;
03336     }
03337     //OK, it's not where it is supposed to be ...
03338     s->gb= s->last_resync_gb;
03339     align_get_bits(&s->gb);
03340     left= s->gb.size_in_bits - get_bits_count(&s->gb);
03341 
03342     for(;left>16+1+5+5; left-=8){
03343         if(show_bits(&s->gb, 16)==0){
03344             GetBitContext bak= s->gb;
03345 
03346             pos= get_bits_count(&s->gb);
03347             if(s->codec_id==CODEC_ID_MPEG4)
03348                 ret= mpeg4_decode_video_packet_header(s);
03349             else
03350                 ret= h263_decode_gob_header(s);
03351             if(ret>=0)
03352                 return pos;
03353 
03354             s->gb= bak;
03355         }
03356         skip_bits(&s->gb, 8);
03357     }
03358 
03359     return -1;
03360 }
03361 
03367 static inline int get_amv(MpegEncContext *s, int n){
03368     int x, y, mb_v, sum, dx, dy, shift;
03369     int len = 1 << (s->f_code + 4);
03370     const int a= s->sprite_warping_accuracy;
03371 
03372     if(s->workaround_bugs & FF_BUG_AMV)
03373         len >>= s->quarter_sample;
03374 
03375     if(s->real_sprite_warping_points==1){
03376         if(s->divx_version==500 && s->divx_build==413)
03377             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
03378         else
03379             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
03380     }else{
03381         dx= s->sprite_delta[n][0];
03382         dy= s->sprite_delta[n][1];
03383         shift= s->sprite_shift[0];
03384         if(n) dy -= 1<<(shift + a + 1);
03385         else  dx -= 1<<(shift + a + 1);
03386         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
03387 
03388         sum=0;
03389         for(y=0; y<16; y++){
03390             int v;
03391 
03392             v= mb_v + dy*y;
03393             //XXX FIXME optimize
03394             for(x=0; x<16; x++){
03395                 sum+= v>>shift;
03396                 v+= dx;
03397             }
03398         }
03399         sum= RSHIFT(sum, a+8-s->quarter_sample);
03400     }
03401 
03402     if      (sum < -len) sum= -len;
03403     else if (sum >= len) sum= len-1;
03404 
03405     return sum;
03406 }
03407 
03412 static int mpeg4_decode_partition_a(MpegEncContext *s){
03413     int mb_num;
03414     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03415 
03416     /* decode first partition */
03417     mb_num=0;
03418     s->first_slice_line=1;
03419     for(; s->mb_y<s->mb_height; s->mb_y++){
03420         ff_init_block_index(s);
03421         for(; s->mb_x<s->mb_width; s->mb_x++){
03422             const int xy= s->mb_x + s->mb_y*s->mb_stride;
03423             int cbpc;
03424             int dir=0;
03425 
03426             mb_num++;
03427             ff_update_block_index(s);
03428             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
03429                 s->first_slice_line=0;
03430 
03431             if(s->pict_type==FF_I_TYPE){
03432                 int i;
03433 
03434                 do{
03435                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
03436                         return mb_num-1;
03437                     }
03438 
03439                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
03440                     if (cbpc < 0){
03441                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
03442                         return -1;
03443                     }
03444                 }while(cbpc == 8);
03445 
03446                 s->cbp_table[xy]= cbpc & 3;
03447                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03448                 s->mb_intra = 1;
03449 
03450                 if(cbpc & 4) {
03451                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03452                 }
03453                 s->current_picture.qscale_table[xy]= s->qscale;
03454 
03455                 s->mbintra_table[xy]= 1;
03456                 for(i=0; i<6; i++){
03457                     int dc_pred_dir;
03458                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
03459                     if(dc < 0){
03460                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
03461                         return -1;
03462                     }
03463                     dir<<=1;
03464                     if(dc_pred_dir) dir|=1;
03465                 }
03466                 s->pred_dir_table[xy]= dir;
03467             }else{ /* P/S_TYPE */
03468                 int mx, my, pred_x, pred_y, bits;
03469                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
03470                 const int stride= s->b8_stride*2;
03471 
03472 try_again:
03473                 bits= show_bits(&s->gb, 17);
03474                 if(bits==MOTION_MARKER){
03475                     return mb_num-1;
03476                 }
03477                 skip_bits1(&s->gb);
03478                 if(bits&0x10000){
03479                     /* skip mb */
03480                     if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03481                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
03482                         mx= get_amv(s, 0);
03483                         my= get_amv(s, 1);
03484                     }else{
03485                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03486                         mx=my=0;
03487                     }
03488                     mot_val[0       ]= mot_val[2       ]=
03489                     mot_val[0+stride]= mot_val[2+stride]= mx;
03490                     mot_val[1       ]= mot_val[3       ]=
03491                     mot_val[1+stride]= mot_val[3+stride]= my;
03492 
03493                     if(s->mbintra_table[xy])
03494                         ff_clean_intra_table_entries(s);
03495                     continue;
03496                 }
03497 
03498                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03499                 if (cbpc < 0){
03500                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
03501                     return -1;
03502                 }
03503                 if(cbpc == 20)
03504                     goto try_again;
03505 
03506                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
03507 
03508                 s->mb_intra = ((cbpc & 4) != 0);
03509 
03510                 if(s->mb_intra){
03511                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03512                     s->mbintra_table[xy]= 1;
03513                     mot_val[0       ]= mot_val[2       ]=
03514                     mot_val[0+stride]= mot_val[2+stride]= 0;
03515                     mot_val[1       ]= mot_val[3       ]=
03516                     mot_val[1+stride]= mot_val[3+stride]= 0;
03517                 }else{
03518                     if(s->mbintra_table[xy])
03519                         ff_clean_intra_table_entries(s);
03520 
03521                     if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
03522                         s->mcsel= get_bits1(&s->gb);
03523                     else s->mcsel= 0;
03524 
03525                     if ((cbpc & 16) == 0) {
03526                         /* 16x16 motion prediction */
03527 
03528                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
03529                         if(!s->mcsel){
03530                             mx = h263_decode_motion(s, pred_x, s->f_code);
03531                             if (mx >= 0xffff)
03532                                 return -1;
03533 
03534                             my = h263_decode_motion(s, pred_y, s->f_code);
03535                             if (my >= 0xffff)
03536                                 return -1;
03537                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
03538                         } else {
03539                             mx = get_amv(s, 0);
03540                             my = get_amv(s, 1);
03541                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
03542                         }
03543 
03544                         mot_val[0       ]= mot_val[2       ] =
03545                         mot_val[0+stride]= mot_val[2+stride]= mx;
03546                         mot_val[1       ]= mot_val[3       ]=
03547                         mot_val[1+stride]= mot_val[3+stride]= my;
03548                     } else {
03549                         int i;
03550                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
03551                         for(i=0;i<4;i++) {
03552                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
03553                             mx = h263_decode_motion(s, pred_x, s->f_code);
03554                             if (mx >= 0xffff)
03555                                 return -1;
03556 
03557                             my = h263_decode_motion(s, pred_y, s->f_code);
03558                             if (my >= 0xffff)
03559                                 return -1;
03560                             mot_val[0] = mx;
03561                             mot_val[1] = my;
03562                         }
03563                     }
03564                 }
03565             }
03566         }
03567         s->mb_x= 0;
03568     }
03569 
03570     return mb_num;
03571 }
03572 
03577 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
03578     int mb_num=0;
03579     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03580 
03581     s->mb_x= s->resync_mb_x;
03582     s->first_slice_line=1;
03583     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
03584         ff_init_block_index(s);
03585         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
03586             const int xy= s->mb_x + s->mb_y*s->mb_stride;
03587 
03588             mb_num++;
03589             ff_update_block_index(s);
03590             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
03591                 s->first_slice_line=0;
03592 
03593             if(s->pict_type==FF_I_TYPE){
03594                 int ac_pred= get_bits1(&s->gb);
03595                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03596                 if(cbpy<0){
03597                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
03598                     return -1;
03599                 }
03600 
03601                 s->cbp_table[xy]|= cbpy<<2;
03602                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
03603             }else{ /* P || S_TYPE */
03604                 if(IS_INTRA(s->current_picture.mb_type[xy])){
03605                     int dir=0,i;
03606                     int ac_pred = get_bits1(&s->gb);
03607                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03608 
03609                     if(cbpy<0){
03610                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
03611                         return -1;
03612                     }
03613 
03614                     if(s->cbp_table[xy] & 8) {
03615                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03616                     }
03617                     s->current_picture.qscale_table[xy]= s->qscale;
03618 
03619                     for(i=0; i<6; i++){
03620                         int dc_pred_dir;
03621                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
03622                         if(dc < 0){
03623                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
03624                             return -1;
03625                         }
03626                         dir<<=1;
03627                         if(dc_pred_dir) dir|=1;
03628                     }
03629                     s->cbp_table[xy]&= 3; //remove dquant
03630                     s->cbp_table[xy]|= cbpy<<2;
03631                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
03632                     s->pred_dir_table[xy]= dir;
03633                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
03634                     s->current_picture.qscale_table[xy]= s->qscale;
03635                     s->cbp_table[xy]= 0;
03636                 }else{
03637                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03638 
03639                     if(cbpy<0){
03640                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
03641                         return -1;
03642                     }
03643 
03644                     if(s->cbp_table[xy] & 8) {
03645                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03646                     }
03647                     s->current_picture.qscale_table[xy]= s->qscale;
03648 
03649                     s->cbp_table[xy]&= 3; //remove dquant
03650                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
03651                 }
03652             }
03653         }
03654         if(mb_num >= mb_count) return 0;
03655         s->mb_x= 0;
03656     }
03657     return 0;
03658 }
03659 
03664 int ff_mpeg4_decode_partitions(MpegEncContext *s)
03665 {
03666     int mb_num;
03667     const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
03668     const int part_a_end  = s->pict_type==FF_I_TYPE ? (DC_END  |MV_END)   : MV_END;
03669 
03670     mb_num= mpeg4_decode_partition_a(s);
03671     if(mb_num<0){
03672         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
03673         return -1;
03674     }
03675 
03676     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
03677         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
03678         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
03679         return -1;
03680     }
03681 
03682     s->mb_num_left= mb_num;
03683 
03684     if(s->pict_type==FF_I_TYPE){
03685         while(show_bits(&s->gb, 9) == 1)
03686             skip_bits(&s->gb, 9);
03687         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
03688             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
03689             return -1;
03690         }
03691     }else{
03692         while(show_bits(&s->gb, 10) == 1)
03693             skip_bits(&s->gb, 10);
03694         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
03695             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
03696             return -1;
03697         }
03698     }
03699     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
03700 
03701     if( mpeg4_decode_partition_b(s, mb_num) < 0){
03702         if(s->pict_type==FF_P_TYPE)
03703             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
03704         return -1;
03705     }else{
03706         if(s->pict_type==FF_P_TYPE)
03707             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
03708     }
03709 
03710     return 0;
03711 }
03712 
03717 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
03718 {
03719     int cbp, mb_type;
03720     const int xy= s->mb_x + s->mb_y*s->mb_stride;
03721 
03722     mb_type= s->current_picture.mb_type[xy];
03723     cbp = s->cbp_table[xy];
03724 
03725     s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
03726 
03727     if(s->current_picture.qscale_table[xy] != s->qscale){
03728         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
03729     }
03730 
03731     if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
03732         int i;
03733         for(i=0; i<4; i++){
03734             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
03735             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
03736         }
03737         s->mb_intra = IS_INTRA(mb_type);
03738 
03739         if (IS_SKIP(mb_type)) {
03740             /* skip mb */
03741             for(i=0;i<6;i++)
03742                 s->block_last_index[i] = -1;
03743             s->mv_dir = MV_DIR_FORWARD;
03744             s->mv_type = MV_TYPE_16X16;
03745             if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03746                 s->mcsel=1;
03747                 s->mb_skipped = 0;
03748             }else{
03749                 s->mcsel=0;
03750                 s->mb_skipped = 1;
03751             }
03752         }else if(s->mb_intra){
03753             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
03754         }else if(!s->mb_intra){
03755 //            s->mcsel= 0; //FIXME do we need to init that
03756 
03757             s->mv_dir = MV_DIR_FORWARD;
03758             if (IS_8X8(mb_type)) {
03759                 s->mv_type = MV_TYPE_8X8;
03760             } else {
03761                 s->mv_type = MV_TYPE_16X16;
03762             }
03763         }
03764     } else { /* I-Frame */
03765         s->mb_intra = 1;
03766         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
03767     }
03768 
03769     if (!IS_SKIP(mb_type)) {
03770         int i;
03771         s->dsp.clear_blocks(s->block[0]);
03772         /* decode each block */
03773         for (i = 0; i < 6; i++) {
03774             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
03775                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
03776                 return -1;
03777             }
03778             cbp+=cbp;
03779         }
03780     }
03781 
03782     /* per-MB end of slice check */
03783 
03784     if(--s->mb_num_left <= 0){
03785 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
03786         if(mpeg4_is_resync(s))
03787             return SLICE_END;
03788         else
03789             return SLICE_NOEND;
03790     }else{
03791         if(mpeg4_is_resync(s)){
03792             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
03793             if(s->cbp_table[xy+delta])
03794                 return SLICE_END;
03795         }
03796         return SLICE_OK;
03797     }
03798 }
03799 
03803 static void preview_obmc(MpegEncContext *s){
03804     GetBitContext gb= s->gb;
03805 
03806     int cbpc, i, pred_x, pred_y, mx, my;
03807     int16_t *mot_val;
03808     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
03809     const int stride= s->b8_stride*2;
03810 
03811     for(i=0; i<4; i++)
03812         s->block_index[i]+= 2;
03813     for(i=4; i<6; i++)
03814         s->block_index[i]+= 1;
03815     s->mb_x++;
03816 
03817     assert(s->pict_type == FF_P_TYPE);
03818 
03819     do{
03820         if (get_bits1(&s->gb)) {
03821             /* skip mb */
03822             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
03823             mot_val[0       ]= mot_val[2       ]=
03824             mot_val[0+stride]= mot_val[2+stride]= 0;
03825             mot_val[1       ]= mot_val[3       ]=
03826             mot_val[1+stride]= mot_val[3+stride]= 0;
03827 
03828             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03829             goto end;
03830         }
03831         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03832     }while(cbpc == 20);
03833 
03834     if(cbpc & 4){
03835         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03836     }else{
03837         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03838         if (cbpc & 8) {
03839             if(s->modified_quant){
03840                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
03841                 else                  skip_bits(&s->gb, 5);
03842             }else
03843                 skip_bits(&s->gb, 2);
03844         }
03845 
03846         if ((cbpc & 16) == 0) {
03847                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
03848                 /* 16x16 motion prediction */
03849                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
03850                 if (s->umvplus)
03851                    mx = h263p_decode_umotion(s, pred_x);
03852                 else
03853                    mx = h263_decode_motion(s, pred_x, 1);
03854 
03855                 if (s->umvplus)
03856                    my = h263p_decode_umotion(s, pred_y);
03857                 else
03858                    my = h263_decode_motion(s, pred_y, 1);
03859 
03860                 mot_val[0       ]= mot_val[2       ]=
03861                 mot_val[0+stride]= mot_val[2+stride]= mx;
03862                 mot_val[1       ]= mot_val[3       ]=
03863                 mot_val[1+stride]= mot_val[3+stride]= my;
03864         } else {
03865             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
03866             for(i=0;i<4;i++) {
03867                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
03868                 if (s->umvplus)
03869                   mx = h263p_decode_umotion(s, pred_x);
03870                 else
03871                   mx = h263_decode_motion(s, pred_x, 1);
03872 
03873                 if (s->umvplus)
03874                   my = h263p_decode_umotion(s, pred_y);
03875                 else
03876                   my = h263_decode_motion(s, pred_y, 1);
03877                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
03878                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
03879                 mot_val[0] = mx;
03880                 mot_val[1] = my;
03881             }
03882         }
03883     }
03884 end:
03885 
03886     for(i=0; i<4; i++)
03887         s->block_index[i]-= 2;
03888     for(i=4; i<6; i++)
03889         s->block_index[i]-= 1;
03890     s->mb_x--;
03891 
03892     s->gb= gb;
03893 }
03894 
03895 static void h263_decode_dquant(MpegEncContext *s){
03896     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03897 
03898     if(s->modified_quant){
03899         if(get_bits1(&s->gb))
03900             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
03901         else
03902             s->qscale= get_bits(&s->gb, 5);
03903     }else
03904         s->qscale += quant_tab[get_bits(&s->gb, 2)];
03905     ff_set_qscale(s, s->qscale);
03906 }
03907 
03908 int ff_h263_decode_mb(MpegEncContext *s,
03909                       DCTELEM block[6][64])
03910 {
03911     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
03912     int16_t *mot_val;
03913     const int xy= s->mb_x + s->mb_y * s->mb_stride;
03914 
03915     assert(!s->h263_pred);
03916 
03917     if (s->pict_type == FF_P_TYPE) {
03918         do{
03919             if (get_bits1(&s->gb)) {
03920                 /* skip mb */
03921                 s->mb_intra = 0;
03922                 for(i=0;i<6;i++)
03923                     s->block_last_index[i] = -1;
03924                 s->mv_dir = MV_DIR_FORWARD;
03925                 s->mv_type = MV_TYPE_16X16;
03926                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03927                 s->mv[0][0][0] = 0;
03928                 s->mv[0][0][1] = 0;
03929                 s->mb_skipped = !(s->obmc | s->loop_filter);
03930                 goto end;
03931             }
03932             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03933             //fprintf(stderr, "\tCBPC: %d", cbpc);
03934             if (cbpc < 0){
03935                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
03936                 return -1;
03937             }
03938         }while(cbpc == 20);
03939 
03940         s->dsp.clear_blocks(s->block[0]);
03941 
03942         dquant = cbpc & 8;
03943         s->mb_intra = ((cbpc & 4) != 0);
03944         if (s->mb_intra) goto intra;
03945 
03946         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03947 
03948         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
03949             cbpy ^= 0xF;
03950 
03951         cbp = (cbpc & 3) | (cbpy << 2);
03952         if (dquant) {
03953             h263_decode_dquant(s);
03954         }
03955 
03956         s->mv_dir = MV_DIR_FORWARD;
03957         if ((cbpc & 16) == 0) {
03958             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
03959             /* 16x16 motion prediction */
03960             s->mv_type = MV_TYPE_16X16;
03961             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
03962             if (s->umvplus)
03963                mx = h263p_decode_umotion(s, pred_x);
03964             else
03965                mx = h263_decode_motion(s, pred_x, 1);
03966 
03967             if (mx >= 0xffff)
03968                 return -1;
03969 
03970             if (s->umvplus)
03971                my = h263p_decode_umotion(s, pred_y);
03972             else
03973                my = h263_decode_motion(s, pred_y, 1);
03974 
03975             if (my >= 0xffff)
03976                 return -1;
03977             s->mv[0][0][0] = mx;
03978             s->mv[0][0][1] = my;
03979 
03980             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
03981                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
03982         } else {
03983             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
03984             s->mv_type = MV_TYPE_8X8;
03985             for(i=0;i<4;i++) {
03986                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
03987                 if (s->umvplus)
03988                   mx = h263p_decode_umotion(s, pred_x);
03989                 else
03990                   mx = h263_decode_motion(s, pred_x, 1);
03991                 if (mx >= 0xffff)
03992                     return -1;
03993 
03994                 if (s->umvplus)
03995                   my = h263p_decode_umotion(s, pred_y);
03996                 else
03997                   my = h263_decode_motion(s, pred_y, 1);
03998                 if (my >= 0xffff)
03999                     return -1;
04000                 s->mv[0][i][0] = mx;
04001                 s->mv[0][i][1] = my;
04002                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
04003                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
04004                 mot_val[0] = mx;
04005                 mot_val[1] = my;
04006             }
04007         }
04008 
04009         /* decode each block */
04010         for (i = 0; i < 6; i++) {
04011             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
04012                 return -1;
04013             cbp+=cbp;
04014         }
04015 
04016         if(s->obmc){
04017             if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
04018                 preview_obmc(s);
04019         }
04020     } else if(s->pict_type==FF_B_TYPE) {
04021         int mb_type;
04022         const int stride= s->b8_stride;
04023         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
04024         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
04025 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
04026 
04027         //FIXME ugly
04028         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
04029         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
04030         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
04031         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
04032 
04033         do{
04034             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
04035             if (mb_type < 0){
04036                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
04037                 return -1;
04038             }
04039 
04040             mb_type= h263_mb_type_b_map[ mb_type ];
04041         }while(!mb_type);
04042 
04043         s->mb_intra = IS_INTRA(mb_type);
04044         if(HAS_CBP(mb_type)){
04045             s->dsp.clear_blocks(s->block[0]);
04046             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
04047             if(s->mb_intra){
04048                 dquant = IS_QUANT(mb_type);
04049                 goto intra;
04050             }
04051 
04052             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
04053 
04054             if (cbpy < 0){
04055                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
04056                 return -1;
04057             }
04058 
04059             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
04060                 cbpy ^= 0xF;
04061 
04062             cbp = (cbpc & 3) | (cbpy << 2);
04063         }else
04064             cbp=0;
04065 
04066         assert(!s->mb_intra);
04067 
04068         if(IS_QUANT(mb_type)){
04069             h263_decode_dquant(s);
04070         }
04071 
04072         if(IS_DIRECT(mb_type)){
04073             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
04074             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
04075         }else{
04076             s->mv_dir = 0;
04077             s->mv_type= MV_TYPE_16X16;
04078 //FIXME UMV
04079 
04080             if(USES_LIST(mb_type, 0)){
04081                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
04082                 s->mv_dir = MV_DIR_FORWARD;
04083 
04084                 mx = h263_decode_motion(s, mx, 1);
04085                 my = h263_decode_motion(s, my, 1);
04086 
04087                 s->mv[0][0][0] = mx;
04088                 s->mv[0][0][1] = my;
04089                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
04090                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
04091             }
04092 
04093             if(USES_LIST(mb_type, 1)){
04094                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
04095                 s->mv_dir |= MV_DIR_BACKWARD;
04096 
04097                 mx = h263_decode_motion(s, mx, 1);
04098                 my = h263_decode_motion(s, my, 1);
04099 
04100                 s->mv[1][0][0] = mx;
04101                 s->mv[1][0][1] = my;
04102                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
04103                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
04104             }
04105         }
04106 
04107         s->current_picture.mb_type[xy]= mb_type;
04108 
04109         /* decode each block */
04110         for (i = 0; i < 6; i++) {
04111             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
04112                 return -1;
04113             cbp+=cbp;
04114         }
04115     } else { /* I-Frame */
04116         do{
04117             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
04118             if (cbpc < 0){
04119                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
04120                 return -1;
04121             }
04122         }while(cbpc == 8);
04123 
04124         s->dsp.clear_blocks(s->block[0]);
04125 
04126         dquant = cbpc & 4;
04127         s->mb_intra = 1;
04128 intra:
04129         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
04130         if (s->h263_aic) {
04131             s->ac_pred = get_bits1(&s->gb);
04132             if(s->ac_pred){
04133                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
04134 
04135                 s->h263_aic_dir = get_bits1(&s->gb);
04136             }
04137         }else
04138             s->ac_pred = 0;
04139 
04140         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
04141         if(cbpy<0){
04142             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
04143             return -1;
04144         }
04145         cbp = (cbpc & 3) | (cbpy << 2);
04146         if (dquant) {
04147             h263_decode_dquant(s);
04148         }
04149 
04150         /* decode each block */
04151         for (i = 0; i < 6; i++) {
04152             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
04153                 return -1;
04154             cbp+=cbp;
04155         }
04156     }
04157 end:
04158 
04159         /* per-MB end of slice check */
04160     {
04161         int v= show_bits(&s->gb, 16);
04162 
04163         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
04164             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
04165         }
04166 
04167         if(v==0)
04168             return SLICE_END;
04169     }
04170 
04171     return SLICE_OK;
04172 }
04173 
04174 int ff_mpeg4_decode_mb(MpegEncContext *s,
04175                       DCTELEM block[6][64])
04176 {
04177     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
04178     int16_t *mot_val;
04179     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
04180     const int xy= s->mb_x + s->mb_y * s->mb_stride;
04181 
04182     assert(s->h263_pred);
04183 
04184     if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
04185         do{
04186             if (get_bits1(&s->gb)) {
04187                 /* skip mb */
04188                 s->mb_intra = 0;
04189                 for(i=0;i<6;i++)
04190                     s->block_last_index[i] = -1;
04191                 s->mv_dir = MV_DIR_FORWARD;
04192                 s->mv_type = MV_TYPE_16X16;
04193                 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
04194                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
04195                     s->mcsel=1;
04196                     s->mv[0][0][0]= get_amv(s, 0);
04197                     s->mv[0][0][1]= get_amv(s, 1);
04198 
04199                     s->mb_skipped = 0;
04200                 }else{
04201                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
04202                     s->mcsel=0;
04203                     s->mv[0][0][0] = 0;
04204                     s->mv[0][0][1] = 0;
04205                     s->mb_skipped = 1;
04206                 }
04207                 goto end;
04208             }
04209             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
04210             //fprintf(stderr, "\tCBPC: %d", cbpc);
04211             if (cbpc < 0){
04212                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
04213                 return -1;
04214             }
04215         }while(cbpc == 20);
04216 
04217         s->dsp.clear_blocks(s->block[0]);
04218         dquant = cbpc & 8;
04219         s->mb_intra = ((cbpc & 4) != 0);
04220         if (s->mb_intra) goto intra;
04221 
04222         if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
04223             s->mcsel= get_bits1(&s->gb);
04224         else s->mcsel= 0;
04225         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
04226 
04227         cbp = (cbpc & 3) | (cbpy << 2);
04228         if (dquant) {
04229             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
04230         }
04231         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
04232             s->interlaced_dct= get_bits1(&s->gb);
04233 
04234         s->mv_dir = MV_DIR_FORWARD;
04235         if ((cbpc & 16) == 0) {
04236             if(s->mcsel){
04237                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
04238                 /* 16x16 global motion prediction */
04239                 s->mv_type = MV_TYPE_16X16;
04240                 mx= get_amv(s, 0);
04241                 my= get_amv(s, 1);
04242                 s->mv[0][0][0] = mx;
04243                 s->mv[0][0][1] = my;
04244             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
04245                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
04246                 /* 16x8 field motion prediction */
04247                 s->mv_type= MV_TYPE_FIELD;
04248 
04249                 s->field_select[0][0]= get_bits1(&s->gb);
04250                 s->field_select[0][1]= get_bits1(&s->gb);
04251 
04252                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
04253 
04254                 for(i=0; i<2; i++){
04255                     mx = h263_decode_motion(s, pred_x, s->f_code);
04256                     if (mx >= 0xffff)
04257                         return -1;
04258 
04259                     my = h263_decode_motion(s, pred_y/2, s->f_code);
04260                     if (my >= 0xffff)
04261                         return -1;
04262 
04263                     s->mv[0][i][0] = mx;
04264                     s->mv[0][i][1] = my;
04265                 }
04266             }else{
04267                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
04268                 /* 16x16 motion prediction */
04269                 s->mv_type = MV_TYPE_16X16;
04270                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
04271                 mx = h263_decode_motion(s, pred_x, s->f_code);
04272 
04273                 if (mx >= 0xffff)
04274                     return -1;
04275 
04276                 my = h263_decode_motion(s, pred_y, s->f_code);
04277 
04278                 if (my >= 0xffff)
04279                     return -1;
04280                 s->mv[0][0][0] = mx;
04281                 s->mv[0][0][1] = my;
04282             }
04283         } else {
04284             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
04285             s->mv_type = MV_TYPE_8X8;
04286             for(i=0;i<4;i++) {
04287                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
04288                 mx = h263_decode_motion(s, pred_x, s->f_code);
04289                 if (mx >= 0xffff)
04290                     return -1;
04291 
04292                 my = h263_decode_motion(s, pred_y, s->f_code);
04293                 if (my >= 0xffff)
04294                     return -1;
04295                 s->mv[0][i][0] = mx;
04296                 s->mv[0][i][1] = my;
04297                 mot_val[0] = mx;
04298                 mot_val[1] = my;
04299             }
04300         }
04301     } else if(s->pict_type==FF_B_TYPE) {
04302         int modb1; // first bit of modb
04303         int modb2; // second bit of modb
04304         int mb_type;
04305 
04306         s->mb_intra = 0; //B-frames never contain intra blocks
04307         s->mcsel=0;      //     ...               true gmc blocks
04308 
04309         if(s->mb_x==0){
04310             for(i=0; i<2; i++){
04311                 s->last_mv[i][0][0]=
04312                 s->last_mv[i][0][1]=
04313                 s->last_mv[i][1][0]=
04314                 s->last_mv[i][1][1]= 0;
04315             }
04316         }
04317 
04318         /* if we skipped it in the future P Frame than skip it now too */
04319         s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
04320 
04321         if(s->mb_skipped){
04322                 /* skip mb */
04323             for(i=0;i<6;i++)
04324                 s->block_last_index[i] = -1;
04325 
04326             s->mv_dir = MV_DIR_FORWARD;
04327             s->mv_type = MV_TYPE_16X16;
04328             s->mv[0][0][0] = 0;
04329             s->mv[0][0][1] = 0;
04330             s->mv[1][0][0] = 0;
04331             s->mv[1][0][1] = 0;
04332             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
04333             goto end;
04334         }
04335 
04336         modb1= get_bits1(&s->gb);
04337         if(modb1){
04338             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
04339             cbp=0;
04340         }else{
04341             modb2= get_bits1(&s->gb);
04342             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
04343             if(mb_type<0){
04344                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
04345                 return -1;
04346             }
04347             mb_type= mb_type_b_map[ mb_type ];
04348             if(modb2) cbp= 0;
04349             else{
04350                 s->dsp.clear_blocks(s->block[0]);
04351                 cbp= get_bits(&s->gb, 6);
04352             }
04353 
04354             if ((!IS_DIRECT(mb_type)) && cbp) {
04355                 if(get_bits1(&s->gb)){
04356                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
04357                 }
04358             }
04359 
04360             if(!s->progressive_sequence){
04361                 if(cbp)
04362                     s->interlaced_dct= get_bits1(&s->gb);
04363 
04364                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
04365                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
04366                     mb_type &= ~MB_TYPE_16x16;
04367 
04368                     if(USES_LIST(mb_type, 0)){
04369                         s->field_select[0][0]= get_bits1(&s->gb);
04370                         s->field_select[0][1]= get_bits1(&s->gb);
04371                     }
04372                     if(USES_LIST(mb_type, 1)){
04373                         s->field_select[1][0]= get_bits1(&s->gb);
04374                         s->field_select[1][1]= get_bits1(&s->gb);
04375                     }
04376                 }
04377             }
04378 
04379             s->mv_dir = 0;
04380             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
04381                 s->mv_type= MV_TYPE_16X16;
04382 
04383                 if(USES_LIST(mb_type, 0)){
04384                     s->mv_dir = MV_DIR_FORWARD;
04385 
04386                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
04387                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
04388                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
04389                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
04390                 }
04391 
04392                 if(USES_LIST(mb_type, 1)){
04393                     s->mv_dir |= MV_DIR_BACKWARD;
04394 
04395                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
04396                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
04397                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
04398                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
04399                 }
04400             }else if(!IS_DIRECT(mb_type)){
04401                 s->mv_type= MV_TYPE_FIELD;
04402 
04403                 if(USES_LIST(mb_type, 0)){
04404                     s->mv_dir = MV_DIR_FORWARD;
04405 
04406                     for(i=0; i<2; i++){
04407                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
04408                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
04409                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
04410                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
04411                     }
04412                 }
04413 
04414                 if(USES_LIST(mb_type, 1)){
04415                     s->mv_dir |= MV_DIR_BACKWARD;
04416 
04417                     for(i=0; i<2; i++){
04418                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
04419                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
04420                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
04421                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
04422                     }
04423                 }
04424             }
04425         }
04426 
04427         if(IS_DIRECT(mb_type)){
04428             if(IS_SKIP(mb_type))
04429                 mx=my=0;
04430             else{
04431                 mx = h263_decode_motion(s, 0, 1);
04432                 my = h263_decode_motion(s, 0, 1);
04433             }
04434 
04435             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
04436             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
04437         }
04438         s->current_picture.mb_type[xy]= mb_type;
04439     } else { /* I-Frame */
04440         do{
04441             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
04442             if (cbpc < 0){
04443                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
04444                 return -1;
04445             }
04446         }while(cbpc == 8);
04447 
04448         dquant = cbpc & 4;
04449         s->mb_intra = 1;
04450 intra:
04451         s->ac_pred = get_bits1(&s->gb);
04452         if(s->ac_pred)
04453             s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
04454         else
04455             s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
04456 
04457         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
04458         if(cbpy<0){
04459             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
04460             return -1;
04461         }
04462         cbp = (cbpc & 3) | (cbpy << 2);
04463 
04464         s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
04465 
04466         if (dquant) {
04467             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
04468         }
04469 
04470         if(!s->progressive_sequence)
04471             s->interlaced_dct= get_bits1(&s->gb);
04472 
04473         s->dsp.clear_blocks(s->block[0]);
04474         /* decode each block */
04475         for (i = 0; i < 6; i++) {
04476             if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
04477                 return -1;
04478             cbp+=cbp;
04479         }
04480         goto end;
04481     }
04482 
04483     /* decode each block */
04484     for (i = 0; i < 6; i++) {
04485         if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
04486             return -1;
04487         cbp+=cbp;
04488     }
04489 end:
04490 
04491         /* per-MB end of slice check */
04492     if(s->codec_id==CODEC_ID_MPEG4){
04493         if(mpeg4_is_resync(s)){
04494             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
04495             if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
04496                 return SLICE_OK;
04497             return SLICE_END;
04498         }
04499     }
04500 
04501     return SLICE_OK;
04502 }
04503 
04504 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
04505 {
04506     int code, val, sign, shift, l;
04507     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
04508 
04509     if (code == 0)
04510         return pred;
04511     if (code < 0)
04512         return 0xffff;
04513 
04514     sign = get_bits1(&s->gb);
04515     shift = f_code - 1;
04516     val = code;
04517     if (shift) {
04518         val = (val - 1) << shift;
04519         val |= get_bits(&s->gb, shift);
04520         val++;
04521     }
04522     if (sign)
04523         val = -val;
04524     val += pred;
04525 
04526     /* modulo decoding */
04527     if (!s->h263_long_vectors) {
04528         l = INT_BIT - 5 - f_code;
04529         val = (val<<l)>>l;
04530     } else {
04531         /* horrible h263 long vector mode */
04532         if (pred < -31 && val < -63)
04533             val += 64;
04534         if (pred > 32 && val > 63)
04535             val -= 64;
04536 
04537     }
04538     return val;
04539 }
04540 
04541 /* Decodes RVLC of H.263+ UMV */
04542 static int h263p_decode_umotion(MpegEncContext * s, int pred)
04543 {
04544    int code = 0, sign;
04545 
04546    if (get_bits1(&s->gb)) /* Motion difference = 0 */
04547       return pred;
04548 
04549    code = 2 + get_bits1(&s->gb);
04550 
04551    while (get_bits1(&s->gb))
04552    {
04553       code <<= 1;
04554       code += get_bits1(&s->gb);
04555    }
04556    sign = code & 1;
04557    code >>= 1;
04558 
04559    code = (sign) ? (pred - code) : (pred + code);
04560 #ifdef DEBUG
04561    av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
04562 #endif
04563    return code;
04564 
04565 }
04566 
04567 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
04568                              int n, int coded)
04569 {
04570     int code, level, i, j, last, run;
04571     RLTable *rl = &rl_inter;
04572     const uint8_t *scan_table;
04573     GetBitContext gb= s->gb;
04574 
04575     scan_table = s->intra_scantable.permutated;
04576     if (s->h263_aic && s->mb_intra) {
04577         rl = &rl_intra_aic;
04578         i = 0;
04579         if (s->ac_pred) {
04580             if (s->h263_aic_dir)
04581                 scan_table = s->intra_v_scantable.permutated; /* left */
04582             else
04583                 scan_table = s->intra_h_scantable.permutated; /* top */
04584         }
04585     } else if (s->mb_intra) {
04586         /* DC coef */
04587         if(s->codec_id == CODEC_ID_RV10){
04588 #if CONFIG_RV10_DECODER
04589           if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) {
04590             int component, diff;
04591             component = (n <= 3 ? 0 : n - 4 + 1);
04592             level = s->last_dc[component];
04593             if (s->rv10_first_dc_coded[component]) {
04594                 diff = rv_decode_dc(s, n);
04595                 if (diff == 0xffff)
04596                     return -1;
04597                 level += diff;
04598                 level = level & 0xff; /* handle wrap round */
04599                 s->last_dc[component] = level;
04600             } else {
04601                 s->rv10_first_dc_coded[component] = 1;
04602             }
04603           } else {
04604                 level = get_bits(&s->gb, 8);
04605                 if (level == 255)
04606                     level = 128;
04607           }
04608 #endif
04609         }else{
04610             level = get_bits(&s->gb, 8);
04611             if((level&0x7F) == 0){
04612                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
04613                 if(s->error_recognition >= FF_ER_COMPLIANT)
04614                     return -1;
04615             }
04616             if (level == 255)
04617                 level = 128;
04618         }
04619         block[0] = level;
04620         i = 1;
04621     } else {
04622         i = 0;
04623     }
04624     if (!coded) {
04625         if (s->mb_intra && s->h263_aic)
04626             goto not_coded;
04627         s->block_last_index[n] = i - 1;
04628         return 0;
04629     }
04630 retry:
04631     for(;;) {
04632         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
04633         if (code < 0){
04634             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
04635             return -1;
04636         }
04637         if (code == rl->n) {
04638             /* escape */
04639             if (s->h263_flv > 1) {
04640                 int is11 = get_bits1(&s->gb);
04641                 last = get_bits1(&s->gb);
04642                 run = get_bits(&s->gb, 6);
04643                 if(is11){
04644                     level = get_sbits(&s->gb, 11);
04645                 } else {
04646                     level = get_sbits(&s->gb, 7);
04647                 }
04648             } else {
04649                 last = get_bits1(&s->gb);
04650                 run = get_bits(&s->gb, 6);
04651                 level = (int8_t)get_bits(&s->gb, 8);
04652                 if(level == -128){
04653                     if (s->codec_id == CODEC_ID_RV10) {
04654                         /* XXX: should patch encoder too */
04655                         level = get_sbits(&s->gb, 12);
04656                     }else{
04657                         level = get_bits(&s->gb, 5);
04658                         level |= get_sbits(&s->gb, 6)<<5;
04659                     }
04660                 }
04661             }
04662         } else {
04663             run = rl->table_run[code];
04664             level = rl->table_level[code];
04665             last = code >= rl->last;
04666             if (get_bits1(&s->gb))
04667                 level = -level;
04668         }
04669         i += run;
04670         if (i >= 64){
04671             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
04672                 //Looks like a hack but no, it's the way it is supposed to work ...
04673                 rl = &rl_intra_aic;
04674                 i = 0;
04675                 s->gb= gb;
04676                 s->dsp.clear_block(block);
04677                 goto retry;
04678             }
04679             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
04680             return -1;
04681         }
04682         j = scan_table[i];
04683         block[j] = level;
04684         if (last)
04685             break;
04686         i++;
04687     }
04688 not_coded:
04689     if (s->mb_intra && s->h263_aic) {
04690         h263_pred_acdc(s, block, n);
04691         i = 63;
04692     }
04693     s->block_last_index[n] = i;
04694     return 0;
04695 }
04696 
04703 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
04704 {
04705     int level, code;
04706 
04707     if (n < 4)
04708         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
04709     else
04710         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
04711     if (code < 0 || code > 9 /* && s->nbit<9 */){
04712         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
04713         return -1;
04714     }
04715     if (code == 0) {
04716         level = 0;
04717     } else {
04718         if(IS_3IV1){
04719             if(code==1)
04720                 level= 2*get_bits1(&s->gb)-1;
04721             else{
04722                 if(get_bits1(&s->gb))
04723                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
04724                 else
04725                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
04726             }
04727         }else{
04728             level = get_xbits(&s->gb, code);
04729         }
04730 
04731         if (code > 8){
04732             if(get_bits1(&s->gb)==0){ /* marker */
04733                 if(s->error_recognition>=2){
04734                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
04735                     return -1;
04736                 }
04737             }
04738         }
04739     }
04740 
04741     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
04742 }
04743 
04748 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
04749                               int n, int coded, int intra, int rvlc)
04750 {
04751     int level, i, last, run;
04752     int dc_pred_dir;
04753     RLTable * rl;
04754     RL_VLC_ELEM * rl_vlc;
04755     const uint8_t * scan_table;
04756     int qmul, qadd;
04757 
04758     //Note intra & rvlc should be optimized away if this is inlined
04759 
04760     if(intra) {
04761       if(s->use_intra_dc_vlc){
04762         /* DC coef */
04763         if(s->partitioned_frame){
04764             level = s->dc_val[0][ s->block_index[n] ];
04765             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
04766             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
04767             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
04768         }else{
04769             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
04770             if (level < 0)
04771                 return -1;
04772         }
04773         block[0] = level;
04774         i = 0;
04775       }else{
04776             i = -1;
04777             ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
04778       }
04779       if (!coded)
04780           goto not_coded;
04781 
04782       if(rvlc){
04783           rl = &rvlc_rl_intra;
04784           rl_vlc = rvlc_rl_intra.rl_vlc[0];
04785       }else{
04786           rl = &rl_intra;
04787           rl_vlc = rl_intra.rl_vlc[0];
04788       }
04789       if (s->ac_pred) {
04790           if (dc_pred_dir == 0)
04791               scan_table = s->intra_v_scantable.permutated; /* left */
04792           else
04793               scan_table = s->intra_h_scantable.permutated; /* top */
04794       } else {
04795             scan_table = s->intra_scantable.permutated;
04796       }
04797       qmul=1;
04798       qadd=0;
04799     } else {
04800         i = -1;
04801         if (!coded) {
04802             s->block_last_index[n] = i;
04803             return 0;
04804         }
04805         if(rvlc) rl = &rvlc_rl_inter;
04806         else     rl = &rl_inter;
04807 
04808         scan_table = s->intra_scantable.permutated;
04809 
04810         if(s->mpeg_quant){
04811             qmul=1;
04812             qadd=0;
04813             if(rvlc){
04814                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
04815             }else{
04816                 rl_vlc = rl_inter.rl_vlc[0];
04817             }
04818         }else{
04819             qmul = s->qscale << 1;
04820             qadd = (s->qscale - 1) | 1;
04821             if(rvlc){
04822                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
04823             }else{
04824                 rl_vlc = rl_inter.rl_vlc[s->qscale];
04825             }
04826         }
04827     }
04828   {
04829     OPEN_READER(re, &s->gb);
04830     for(;;) {
04831         UPDATE_CACHE(re, &s->gb);
04832         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
04833         if (level==0) {
04834           /* escape */
04835           if(rvlc){
04836                 if(SHOW_UBITS(re, &s->gb, 1)==0){
04837                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
04838                     return -1;
04839                 }; SKIP_CACHE(re, &s->gb, 1);
04840 
04841                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
04842                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
04843                 SKIP_COUNTER(re, &s->gb, 1+1+6);
04844                 UPDATE_CACHE(re, &s->gb);
04845 
04846                 if(SHOW_UBITS(re, &s->gb, 1)==0){
04847                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
04848                     return -1;
04849                 }; SKIP_CACHE(re, &s->gb, 1);
04850 
04851                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
04852 
04853                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
04854                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
04855                     return -1;
04856                 }; SKIP_CACHE(re, &s->gb, 5);
04857 
04858                 level=  level * qmul + qadd;
04859                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
04860                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
04861 
04862                 i+= run + 1;
04863                 if(last) i+=192;
04864           }else{
04865             int cache;
04866             cache= GET_CACHE(re, &s->gb);
04867 
04868             if(IS_3IV1)
04869                 cache ^= 0xC0000000;
04870 
04871             if (cache&0x80000000) {
04872                 if (cache&0x40000000) {
04873                     /* third escape */
04874                     SKIP_CACHE(re, &s->gb, 2);
04875                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
04876                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
04877                     SKIP_COUNTER(re, &s->gb, 2+1+6);
04878                     UPDATE_CACHE(re, &s->gb);
04879 
04880                     if(IS_3IV1){
04881                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
04882                     }else{
04883                         if(SHOW_UBITS(re, &s->gb, 1)==0){
04884                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
04885                             return -1;
04886                         }; SKIP_CACHE(re, &s->gb, 1);
04887 
04888                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
04889 
04890                         if(SHOW_UBITS(re, &s->gb, 1)==0){
04891                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
04892                             return -1;
04893                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
04894 
04895                         SKIP_COUNTER(re, &s->gb, 1+12+1);
04896                     }
04897 
04898 #if 0
04899                     if(s->error_recognition >= FF_ER_COMPLIANT){
04900                         const int abs_level= FFABS(level);
04901                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
04902                             const int run1= run - rl->max_run[last][abs_level] - 1;
04903                             if(abs_level <= rl->max_level[last][run]){
04904                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
04905                                 return -1;
04906                             }
04907                             if(s->error_recognition > FF_ER_COMPLIANT){
04908                                 if(abs_level <= rl->max_level[last][run]*2){
04909                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
04910                                     return -1;
04911                                 }
04912                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
04913                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
04914                                     return -1;
04915                                 }
04916                             }
04917                         }
04918                     }
04919 #endif
04920                     if (level>0) level= level * qmul + qadd;
04921                     else         level= level * qmul - qadd;
04922 
04923                     if((unsigned)(level + 2048) > 4095){
04924                         if(s->error_recognition > FF_ER_COMPLIANT){
04925                             if(level > 2560 || level<-2560){
04926                                 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
04927                                 return -1;
04928                             }
04929                         }
04930                         level= level<0 ? -2048 : 2047;
04931                     }
04932 
04933                     i+= run + 1;
04934                     if(last) i+=192;
04935                 } else {
04936                     /* second escape */
04937 #if MIN_CACHE_BITS < 20
04938                     LAST_SKIP_BITS(re, &s->gb, 2);
04939                     UPDATE_CACHE(re, &s->gb);
04940 #else
04941                     SKIP_BITS(re, &s->gb, 2);
04942 #endif
04943                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
04944                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
04945                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
04946                     LAST_SKIP_BITS(re, &s->gb, 1);
04947                 }
04948             } else {
04949                 /* first escape */
04950 #if MIN_CACHE_BITS < 19
04951                 LAST_SKIP_BITS(re, &s->gb, 1);
04952                 UPDATE_CACHE(re, &s->gb);
04953 #else
04954                 SKIP_BITS(re, &s->gb, 1);
04955 #endif
04956                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
04957                 i+= run;
04958                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
04959                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
04960                 LAST_SKIP_BITS(re, &s->gb, 1);
04961             }
04962           }
04963         } else {
04964             i+= run;
04965             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
04966             LAST_SKIP_BITS(re, &s->gb, 1);
04967         }
04968         if (i > 62){
04969             i-= 192;
04970             if(i&(~63)){
04971                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
04972                 return -1;
04973             }
04974 
04975             block[scan_table[i]] = level;
04976             break;
04977         }
04978 
04979         block[scan_table[i]] = level;
04980     }
04981     CLOSE_READER(re, &s->gb);
04982   }
04983  not_coded:
04984     if (intra) {
04985         if(!s->use_intra_dc_vlc){
04986             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
04987 
04988             i -= i>>31; //if(i == -1) i=0;
04989         }
04990 
04991         mpeg4_pred_ac(s, block, n, dc_pred_dir);
04992         if (s->ac_pred) {
04993             i = 63; /* XXX: not optimal */
04994         }
04995     }
04996     s->block_last_index[n] = i;
04997     return 0;
04998 }
04999 
05000 /* most is hardcoded. should extend to handle all h263 streams */
05001 int h263_decode_picture_header(MpegEncContext *s)
05002 {
05003     int format, width, height, i;
05004     uint32_t startcode;
05005 
05006     align_get_bits(&s->gb);
05007 
05008     startcode= get_bits(&s->gb, 22-8);
05009 
05010     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
05011         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
05012 
05013         if(startcode == 0x20)
05014             break;
05015     }
05016 
05017     if (startcode != 0x20) {
05018         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
05019         return -1;
05020     }
05021     /* temporal reference */
05022     i = get_bits(&s->gb, 8); /* picture timestamp */
05023     if( (s->picture_number&~0xFF)+i < s->picture_number)
05024         i+= 256;
05025     s->current_picture_ptr->pts=
05026     s->picture_number= (s->picture_number&~0xFF) + i;
05027 
05028     /* PTYPE starts here */
05029     if (get_bits1(&s->gb) != 1) {
05030         /* marker */
05031         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
05032         return -1;
05033     }
05034     if (get_bits1(&s->gb) != 0) {
05035         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
05036         return -1;      /* h263 id */
05037     }
05038     skip_bits1(&s->gb);         /* split screen off */
05039     skip_bits1(&s->gb);         /* camera  off */
05040     skip_bits1(&s->gb);         /* freeze picture release off */
05041 
05042     format = get_bits(&s->gb, 3);
05043     /*
05044         0    forbidden
05045         1    sub-QCIF
05046         10   QCIF
05047         7       extended PTYPE (PLUSPTYPE)
05048     */
05049 
05050     if (format != 7 && format != 6) {
05051         s->h263_plus = 0;
05052         /* H.263v1 */
05053         width = h263_format[format][0];
05054         height = h263_format[format][1];
05055         if (!width)
05056             return -1;
05057 
05058         s->pict_type = FF_I_TYPE + get_bits1(&s->gb);
05059 
05060         s->h263_long_vectors = get_bits1(&s->gb);
05061 
05062         if (get_bits1(&s->gb) != 0) {
05063             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
05064             return -1; /* SAC: off */
05065         }
05066         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
05067         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
05068 
05069         if (get_bits1(&s->gb) != 0) {
05070             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
05071             return -1; /* not PB frame */
05072         }
05073         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
05074         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
05075 
05076         s->width = width;
05077         s->height = height;
05078         s->avctx->sample_aspect_ratio= (AVRational){12,11};
05079         s->avctx->time_base= (AVRational){1001, 30000};
05080     } else {
05081         int ufep;
05082 
05083         /* H.263v2 */
05084         s->h263_plus = 1;
05085         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
05086 
05087         /* ufep other than 0 and 1 are reserved */
05088         if (ufep == 1) {
05089             /* OPPTYPE */
05090             format = get_bits(&s->gb, 3);
05091             dprintf(s->avctx, "ufep=1, format: %d\n", format);
05092             s->custom_pcf= get_bits1(&s->gb);
05093             s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
05094             if (get_bits1(&s->gb) != 0) {
05095                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
05096             }
05097             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
05098             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
05099             s->loop_filter= get_bits1(&s->gb);
05100             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
05101 
05102             s->h263_slice_structured= get_bits1(&s->gb);
05103             if (get_bits1(&s->gb) != 0) {
05104                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
05105             }
05106             if (get_bits1(&s->gb) != 0) {
05107                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
05108             }
05109             s->alt_inter_vlc= get_bits1(&s->gb);
05110             s->modified_quant= get_bits1(&s->gb);
05111             if(s->modified_quant)
05112                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
05113 
05114             skip_bits(&s->gb, 1); /* Prevent start code emulation */
05115 
05116             skip_bits(&s->gb, 3); /* Reserved */
05117         } else if (ufep != 0) {
05118             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
05119             return -1;
05120         }
05121 
05122         /* MPPTYPE */
05123         s->pict_type = get_bits(&s->gb, 3);
05124         switch(s->pict_type){
05125         case 0: s->pict_type= FF_I_TYPE;break;
05126         case 1: s->pict_type= FF_P_TYPE;break;
05127         case 3: s->pict_type= FF_B_TYPE;break;
05128         case 7: s->pict_type= FF_I_TYPE;break; //ZYGO
05129         default:
05130             return -1;
05131         }
05132         skip_bits(&s->gb, 2);
05133         s->no_rounding = get_bits1(&s->gb);
05134         skip_bits(&s->gb, 4);
05135 
05136         /* Get the picture dimensions */
05137         if (ufep) {
05138             if (format == 6) {
05139                 /* Custom Picture Format (CPFMT) */
05140                 s->aspect_ratio_info = get_bits(&s->gb, 4);
05141                 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
05142                 /* aspect ratios:
05143                 0 - forbidden
05144                 1 - 1:1
05145                 2 - 12:11 (CIF 4:3)
05146                 3 - 10:11 (525-type 4:3)
05147                 4 - 16:11 (CIF 16:9)
05148                 5 - 40:33 (525-type 16:9)
05149                 6-14 - reserved
05150                 */
05151                 width = (get_bits(&s->gb, 9) + 1) * 4;
05152                 skip_bits1(&s->gb);
05153                 height = get_bits(&s->gb, 9) * 4;
05154                 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
05155                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
05156                     /* aspected dimensions */
05157                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
05158                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
05159                 }else{
05160                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
05161                 }
05162             } else {
05163                 width = h263_format[format][0];
05164                 height = h263_format[format][1];
05165                 s->avctx->sample_aspect_ratio= (AVRational){12,11};
05166             }
05167             if ((width == 0) || (height == 0))
05168                 return -1;
05169             s->width = width;
05170             s->height = height;
05171 
05172             if(s->custom_pcf){
05173                 int gcd;
05174                 s->avctx->time_base.den= 1800000;
05175                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
05176                 s->avctx->time_base.num*= get_bits(&s->gb, 7);
05177                 if(s->avctx->time_base.num == 0){
05178                     av_log(s, AV_LOG_ERROR, "zero framerate\n");
05179                     return -1;
05180                 }
05181                 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
05182                 s->avctx->time_base.den /= gcd;
05183                 s->avctx->time_base.num /= gcd;
05184 //                av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
05185             }else{
05186                 s->avctx->time_base= (AVRational){1001, 30000};
05187             }
05188         }
05189 
05190         if(s->custom_pcf){
05191             skip_bits(&s->gb, 2); //extended Temporal reference
05192         }
05193 
05194         if (ufep) {
05195             if (s->umvplus) {
05196                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
05197                     skip_bits1(&s->gb);
05198             }
05199             if(s->h263_slice_structured){
05200                 if (get_bits1(&s->gb) != 0) {
05201                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
05202                 }
05203                 if (get_bits1(&s->gb) != 0) {
05204                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
05205                 }
05206             }
05207         }
05208 
05209         s->qscale = get_bits(&s->gb, 5);
05210     }
05211 
05212     s->mb_width = (s->width  + 15) / 16;
05213     s->mb_height = (s->height  + 15) / 16;
05214     s->mb_num = s->mb_width * s->mb_height;
05215 
05216     /* PEI */
05217     while (get_bits1(&s->gb) != 0) {
05218         skip_bits(&s->gb, 8);
05219     }
05220 
05221     if(s->h263_slice_structured){
05222         if (get_bits1(&s->gb) != 1) {
05223             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
05224             return -1;
05225         }
05226 
05227         ff_h263_decode_mba(s);
05228 
05229         if (get_bits1(&s->gb) != 1) {
05230             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
05231             return -1;
05232         }
05233     }
05234     s->f_code = 1;
05235 
05236     if(s->h263_aic){
05237          s->y_dc_scale_table=
05238          s->c_dc_scale_table= ff_aic_dc_scale_table;
05239     }else{
05240         s->y_dc_scale_table=
05241         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
05242     }
05243 
05244      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
05245         show_pict_info(s);
05246      }
05247 #if 1
05248     if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){
05249         int i,j;
05250         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
05251         av_log(s->avctx, AV_LOG_DEBUG, "\n");
05252         for(i=0; i<13; i++){
05253             for(j=0; j<3; j++){
05254                 int v= get_bits(&s->gb, 8);
05255                 v |= get_sbits(&s->gb, 8)<<8;
05256                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
05257             }
05258             av_log(s->avctx, AV_LOG_DEBUG, "\n");
05259         }
05260         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
05261     }
05262 #endif
05263 
05264     return 0;
05265 }
05266 
05267 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
05268 {
05269     int i;
05270     int a= 2<<s->sprite_warping_accuracy;
05271     int rho= 3-s->sprite_warping_accuracy;
05272     int r=16/a;
05273     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
05274     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
05275     int sprite_ref[4][2];
05276     int virtual_ref[2][2];
05277     int w2, h2, w3, h3;
05278     int alpha=0, beta=0;
05279     int w= s->width;
05280     int h= s->height;
05281     int min_ab;
05282 
05283     for(i=0; i<s->num_sprite_warping_points; i++){
05284         int length;
05285         int x=0, y=0;
05286 
05287         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
05288         if(length){
05289             x= get_xbits(gb, length);
05290         }
05291         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
05292 
05293         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
05294         if(length){
05295             y=get_xbits(gb, length);
05296         }
05297         skip_bits1(gb); /* marker bit */
05298 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
05299         d[i][0]= x;
05300         d[i][1]= y;
05301     }
05302 
05303     while((1<<alpha)<w) alpha++;
05304     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
05305     w2= 1<<alpha;
05306     h2= 1<<beta;
05307 
05308 // Note, the 4th point isn't used for GMC
05309     if(s->divx_version==500 && s->divx_build==413){
05310         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
05311         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
05312         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
05313         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
05314         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
05315         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
05316     } else {
05317         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
05318         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
05319         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
05320         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
05321         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
05322         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
05323     }
05324 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
05325     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
05326 
05327 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
05328 // perhaps it should be reordered to be more readable ...
05329 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
05330 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
05331     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
05332         + 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);
05333     virtual_ref[0][1]= 16*vop_ref[0][1]
05334         + 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);
05335     virtual_ref[1][0]= 16*vop_ref[0][0]
05336         + 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);
05337     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
05338         + 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);
05339 
05340     switch(s->num_sprite_warping_points)
05341     {
05342         case 0:
05343             s->sprite_offset[0][0]= 0;
05344             s->sprite_offset[0][1]= 0;
05345             s->sprite_offset[1][0]= 0;
05346             s->sprite_offset[1][1]= 0;
05347             s->sprite_delta[0][0]= a;
05348             s->sprite_delta[0][1]= 0;
05349             s->sprite_delta[1][0]= 0;
05350             s->sprite_delta[1][1]= a;
05351             s->sprite_shift[0]= 0;
05352             s->sprite_shift[1]= 0;
05353             break;
05354         case 1: //GMC only
05355             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
05356             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
05357             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
05358             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
05359             s->sprite_delta[0][0]= a;
05360             s->sprite_delta[0][1]= 0;
05361             s->sprite_delta[1][0]= 0;
05362             s->sprite_delta[1][1]= a;
05363             s->sprite_shift[0]= 0;
05364             s->sprite_shift[1]= 0;
05365             break;
05366         case 2:
05367             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
05368                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
05369                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
05370                                                   + (1<<(alpha+rho-1));
05371             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
05372                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
05373                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
05374                                                   + (1<<(alpha+rho-1));
05375             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
05376                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
05377                                      +2*w2*r*sprite_ref[0][0]
05378                                      - 16*w2
05379                                      + (1<<(alpha+rho+1)));
05380             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
05381                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
05382                                      +2*w2*r*sprite_ref[0][1]
05383                                      - 16*w2
05384                                      + (1<<(alpha+rho+1)));
05385             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
05386             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
05387             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
05388             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
05389 
05390             s->sprite_shift[0]= alpha+rho;
05391             s->sprite_shift[1]= alpha+rho+2;
05392             break;
05393         case 3:
05394             min_ab= FFMIN(alpha, beta);
05395             w3= w2>>min_ab;
05396             h3= h2>>min_ab;
05397             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
05398                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
05399                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
05400                                    + (1<<(alpha+beta+rho-min_ab-1));
05401             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
05402                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
05403                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
05404                                    + (1<<(alpha+beta+rho-min_ab-1));
05405             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
05406                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
05407                                    + 2*w2*h3*r*sprite_ref[0][0]
05408                                    - 16*w2*h3
05409                                    + (1<<(alpha+beta+rho-min_ab+1));
05410             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
05411                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
05412                                    + 2*w2*h3*r*sprite_ref[0][1]
05413                                    - 16*w2*h3
05414                                    + (1<<(alpha+beta+rho-min_ab+1));
05415             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
05416             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
05417             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
05418             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
05419 
05420             s->sprite_shift[0]= alpha + beta + rho - min_ab;
05421             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
05422             break;
05423     }
05424     /* try to simplify the situation */
05425     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
05426        && s->sprite_delta[0][1] == 0
05427        && s->sprite_delta[1][0] == 0
05428        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
05429     {
05430         s->sprite_offset[0][0]>>=s->sprite_shift[0];
05431         s->sprite_offset[0][1]>>=s->sprite_shift[0];
05432         s->sprite_offset[1][0]>>=s->sprite_shift[1];
05433         s->sprite_offset[1][1]>>=s->sprite_shift[1];
05434         s->sprite_delta[0][0]= a;
05435         s->sprite_delta[0][1]= 0;
05436         s->sprite_delta[1][0]= 0;
05437         s->sprite_delta[1][1]= a;
05438         s->sprite_shift[0]= 0;
05439         s->sprite_shift[1]= 0;
05440         s->real_sprite_warping_points=1;
05441     }
05442     else{
05443         int shift_y= 16 - s->sprite_shift[0];
05444         int shift_c= 16 - s->sprite_shift[1];
05445 //printf("shifts %d %d\n", shift_y, shift_c);
05446         for(i=0; i<2; i++){
05447             s->sprite_offset[0][i]<<= shift_y;
05448             s->sprite_offset[1][i]<<= shift_c;
05449             s->sprite_delta[0][i]<<= shift_y;
05450             s->sprite_delta[1][i]<<= shift_y;
05451             s->sprite_shift[i]= 16;
05452         }
05453         s->real_sprite_warping_points= s->num_sprite_warping_points;
05454     }
05455 #if 0
05456 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
05457     vop_ref[0][0], vop_ref[0][1],
05458     vop_ref[1][0], vop_ref[1][1],
05459     vop_ref[2][0], vop_ref[2][1],
05460     sprite_ref[0][0], sprite_ref[0][1],
05461     sprite_ref[1][0], sprite_ref[1][1],
05462     sprite_ref[2][0], sprite_ref[2][1],
05463     virtual_ref[0][0], virtual_ref[0][1],
05464     virtual_ref[1][0], virtual_ref[1][1]
05465     );
05466 
05467 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
05468     s->sprite_offset[0][0], s->sprite_offset[0][1],
05469     s->sprite_delta[0][0], s->sprite_delta[0][1],
05470     s->sprite_delta[1][0], s->sprite_delta[1][1],
05471     s->sprite_shift[0]
05472     );
05473 #endif
05474 }
05475 
05476 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
05477     int hours, minutes, seconds;
05478 
05479     hours= get_bits(gb, 5);
05480     minutes= get_bits(gb, 6);
05481     skip_bits1(gb);
05482     seconds= get_bits(gb, 6);
05483 
05484     s->time_base= seconds + 60*(minutes + 60*hours);
05485 
05486     skip_bits1(gb);
05487     skip_bits1(gb);
05488 
05489     return 0;
05490 }
05491 
05492 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
05493     int width, height, vo_ver_id;
05494 
05495     /* vol header */
05496     skip_bits(gb, 1); /* random access */
05497     s->vo_type= get_bits(gb, 8);
05498     if (get_bits1(gb) != 0) { /* is_ol_id */
05499         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
05500         skip_bits(gb, 3); /* vo_priority */
05501     } else {
05502         vo_ver_id = 1;
05503     }
05504 //printf("vo type:%d\n",s->vo_type);
05505     s->aspect_ratio_info= get_bits(gb, 4);
05506     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
05507         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
05508         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
05509     }else{
05510         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
05511     }
05512 
05513     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
05514         int chroma_format= get_bits(gb, 2);
05515         if(chroma_format!=CHROMA_420){
05516             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
05517         }
05518         s->low_delay= get_bits1(gb);
05519         if(get_bits1(gb)){ /* vbv parameters */
05520             get_bits(gb, 15);   /* first_half_bitrate */
05521             skip_bits1(gb);     /* marker */
05522             get_bits(gb, 15);   /* latter_half_bitrate */
05523             skip_bits1(gb);     /* marker */
05524             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
05525             skip_bits1(gb);     /* marker */
05526             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
05527             get_bits(gb, 11);   /* first_half_vbv_occupancy */
05528             skip_bits1(gb);     /* marker */
05529             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
05530             skip_bits1(gb);     /* marker */
05531         }
05532     }else{
05533         // set low delay flag only once the smartest? low delay detection won't be overriden
05534         if(s->picture_number==0)
05535             s->low_delay=0;
05536     }
05537 
05538     s->shape = get_bits(gb, 2); /* vol shape */
05539     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
05540     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
05541         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
05542         skip_bits(gb, 4);  //video_object_layer_shape_extension
05543     }
05544 
05545     check_marker(gb, "before time_increment_resolution");
05546 
05547     s->avctx->time_base.den = get_bits(gb, 16);
05548     if(!s->avctx->time_base.den){
05549         av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
05550         return -1;
05551     }
05552 
05553     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
05554     if (s->time_increment_bits < 1)
05555         s->time_increment_bits = 1;
05556 
05557     check_marker(gb, "before fixed_vop_rate");
05558 
05559     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
05560         s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
05561     }else
05562         s->avctx->time_base.num = 1;
05563 
05564     s->t_frame=0;
05565 
05566     if (s->shape != BIN_ONLY_SHAPE) {
05567         if (s->shape == RECT_SHAPE) {
05568             skip_bits1(gb);   /* marker */
05569             width = get_bits(gb, 13);
05570             skip_bits1(gb);   /* marker */
05571             height = get_bits(gb, 13);
05572             skip_bits1(gb);   /* marker */
05573             if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */
05574                 s->width = width;
05575                 s->height = height;
05576 //                printf("width/height: %d %d\n", width, height);
05577             }
05578         }
05579 
05580         s->progressive_sequence=
05581         s->progressive_frame= get_bits1(gb)^1;
05582         s->interlaced_dct=0;
05583         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
05584             av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
05585         if (vo_ver_id == 1) {
05586             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
05587         } else {
05588             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
05589         }
05590         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
05591         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
05592             if(s->vol_sprite_usage==STATIC_SPRITE){
05593                 s->sprite_width = get_bits(gb, 13);
05594                 skip_bits1(gb); /* marker */
05595                 s->sprite_height= get_bits(gb, 13);
05596                 skip_bits1(gb); /* marker */
05597                 s->sprite_left  = get_bits(gb, 13);
05598                 skip_bits1(gb); /* marker */
05599                 s->sprite_top   = get_bits(gb, 13);
05600                 skip_bits1(gb); /* marker */
05601             }
05602             s->num_sprite_warping_points= get_bits(gb, 6);
05603             if(s->num_sprite_warping_points > 3){
05604                 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
05605                 s->num_sprite_warping_points= 0;
05606                 return -1;
05607             }
05608             s->sprite_warping_accuracy = get_bits(gb, 2);
05609             s->sprite_brightness_change= get_bits1(gb);
05610             if(s->vol_sprite_usage==STATIC_SPRITE)
05611                 s->low_latency_sprite= get_bits1(gb);
05612         }
05613         // FIXME sadct disable bit if verid!=1 && shape not rect
05614 
05615         if (get_bits1(gb) == 1) {   /* not_8_bit */
05616             s->quant_precision = get_bits(gb, 4); /* quant_precision */
05617             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
05618             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
05619         } else {
05620             s->quant_precision = 5;
05621         }
05622 
05623         // FIXME a bunch of grayscale shape things
05624 
05625         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
05626             int i, v;
05627 
05628             /* load default matrixes */
05629             for(i=0; i<64; i++){
05630                 int j= s->dsp.idct_permutation[i];
05631                 v= ff_mpeg4_default_intra_matrix[i];
05632                 s->intra_matrix[j]= v;
05633                 s->chroma_intra_matrix[j]= v;
05634 
05635                 v= ff_mpeg4_default_non_intra_matrix[i];
05636                 s->inter_matrix[j]= v;
05637                 s->chroma_inter_matrix[j]= v;
05638             }
05639 
05640             /* load custom intra matrix */
05641             if(get_bits1(gb)){
05642                 int last=0;
05643                 for(i=0; i<64; i++){
05644                     int j;
05645                     v= get_bits(gb, 8);
05646                     if(v==0) break;
05647 
05648                     last= v;
05649                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05650                     s->intra_matrix[j]= v;
05651                     s->chroma_intra_matrix[j]= v;
05652                 }
05653 
05654                 /* replicate last value */
05655                 for(; i<64; i++){
05656                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05657                     s->intra_matrix[j]= last;
05658                     s->chroma_intra_matrix[j]= last;
05659                 }
05660             }
05661 
05662             /* load custom non intra matrix */
05663             if(get_bits1(gb)){
05664                 int last=0;
05665                 for(i=0; i<64; i++){
05666                     int j;
05667                     v= get_bits(gb, 8);
05668                     if(v==0) break;
05669 
05670                     last= v;
05671                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05672                     s->inter_matrix[j]= v;
05673                     s->chroma_inter_matrix[j]= v;
05674                 }
05675 
05676                 /* replicate last value */
05677                 for(; i<64; i++){
05678                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05679                     s->inter_matrix[j]= last;
05680                     s->chroma_inter_matrix[j]= last;
05681                 }
05682             }
05683 
05684             // FIXME a bunch of grayscale shape things
05685         }
05686 
05687         if(vo_ver_id != 1)
05688              s->quarter_sample= get_bits1(gb);
05689         else s->quarter_sample=0;
05690 
05691         if(!get_bits1(gb)){
05692             int pos= get_bits_count(gb);
05693             int estimation_method= get_bits(gb, 2);
05694             if(estimation_method<2){
05695                 if(!get_bits1(gb)){
05696                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque
05697                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent
05698                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae
05699                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae
05700                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update
05701                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling
05702                 }
05703                 if(!get_bits1(gb)){
05704                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks
05705                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks
05706                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks
05707                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks
05708                 }
05709                 if(!check_marker(gb, "in complexity estimation part 1")){
05710                     skip_bits_long(gb, pos - get_bits_count(gb));
05711                     goto no_cplx_est;
05712                 }
05713                 if(!get_bits1(gb)){
05714                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs
05715                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines
05716                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms
05717                     s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits
05718                 }
05719                 if(!get_bits1(gb)){
05720                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm
05721                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm
05722                     s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q
05723                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q
05724                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2
05725                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4
05726                 }
05727                 if(!check_marker(gb, "in complexity estimation part 2")){
05728                     skip_bits_long(gb, pos - get_bits_count(gb));
05729                     goto no_cplx_est;
05730                 }
05731                 if(estimation_method==1){
05732                     s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct
05733                     s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel
05734                 }
05735             }else
05736                 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method);
05737         }else{
05738 no_cplx_est:
05739             s->cplx_estimation_trash_i=
05740             s->cplx_estimation_trash_p=
05741             s->cplx_estimation_trash_b= 0;
05742         }
05743 
05744         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
05745 
05746         s->data_partitioning= get_bits1(gb);
05747         if(s->data_partitioning){
05748             s->rvlc= get_bits1(gb);
05749         }
05750 
05751         if(vo_ver_id != 1) {
05752             s->new_pred= get_bits1(gb);
05753             if(s->new_pred){
05754                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
05755                 skip_bits(gb, 2); /* requested upstream message type */
05756                 skip_bits1(gb); /* newpred segment type */
05757             }
05758             s->reduced_res_vop= get_bits1(gb);
05759             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
05760         }
05761         else{
05762             s->new_pred=0;
05763             s->reduced_res_vop= 0;
05764         }
05765 
05766         s->scalability= get_bits1(gb);
05767 
05768         if (s->scalability) {
05769             GetBitContext bak= *gb;
05770             int ref_layer_id;
05771             int ref_layer_sampling_dir;
05772             int h_sampling_factor_n;
05773             int h_sampling_factor_m;
05774             int v_sampling_factor_n;
05775             int v_sampling_factor_m;
05776 
05777             s->hierachy_type= get_bits1(gb);
05778             ref_layer_id= get_bits(gb, 4);
05779             ref_layer_sampling_dir= get_bits1(gb);
05780             h_sampling_factor_n= get_bits(gb, 5);
05781             h_sampling_factor_m= get_bits(gb, 5);
05782             v_sampling_factor_n= get_bits(gb, 5);
05783             v_sampling_factor_m= get_bits(gb, 5);
05784             s->enhancement_type= get_bits1(gb);
05785 
05786             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
05787                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
05788 
05789 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
05790                 s->scalability=0;
05791 
05792                 *gb= bak;
05793             }else
05794                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
05795 
05796             // bin shape stuff FIXME
05797         }
05798     }
05799     return 0;
05800 }
05801 
05806 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
05807     char buf[256];
05808     int i;
05809     int e;
05810     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
05811     char last;
05812 
05813     for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
05814         if(show_bits(gb, 23) == 0) break;
05815         buf[i]= get_bits(gb, 8);
05816     }
05817     buf[i]=0;
05818 
05819     /* divx detection */
05820     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
05821     if(e<2)
05822         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
05823     if(e>=2){
05824         s->divx_version= ver;
05825         s->divx_build= build;
05826         s->divx_packed= e==3 && last=='p';
05827         if(s->divx_packed && !s->showed_packed_warning) {
05828             av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n");
05829             s->showed_packed_warning=1;
05830         }
05831     }
05832 
05833     /* ffmpeg detection */
05834     e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
05835     if(e!=4)
05836         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
05837     if(e!=4){
05838         e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
05839         if (e>1)
05840             build= (ver<<16) + (ver2<<8) + ver3;
05841     }
05842     if(e!=4){
05843         if(strcmp(buf, "ffmpeg")==0){
05844             s->lavc_build= 4600;
05845         }
05846     }
05847     if(e==4){
05848         s->lavc_build= build;
05849     }
05850 
05851     /* Xvid detection */
05852     e=sscanf(buf, "XviD%d", &build);
05853     if(e==1){
05854         s->xvid_build= build;
05855     }
05856 
05857 //printf("User Data: %s\n", buf);
05858     return 0;
05859 }
05860 
05861 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
05862     int time_incr, time_increment;
05863 
05864     s->pict_type = get_bits(gb, 2) + FF_I_TYPE;        /* pict type: I = 0 , P = 1 */
05865     if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
05866         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
05867         s->low_delay=0;
05868     }
05869 
05870     s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
05871     if(s->partitioned_frame)
05872         s->decode_mb= mpeg4_decode_partitioned_mb;
05873     else
05874         s->decode_mb= ff_mpeg4_decode_mb;
05875 
05876     time_incr=0;
05877     while (get_bits1(gb) != 0)
05878         time_incr++;
05879 
05880     check_marker(gb, "before time_increment");
05881 
05882     if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
05883         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
05884 
05885         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
05886             if(show_bits(gb, s->time_increment_bits+1)&1) break;
05887         }
05888 
05889         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
05890     }
05891 
05892     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
05893     else time_increment= get_bits(gb, s->time_increment_bits);
05894 
05895 //    printf("%d %X\n", s->time_increment_bits, time_increment);
05896 //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);
05897     if(s->pict_type!=FF_B_TYPE){
05898         s->last_time_base= s->time_base;
05899         s->time_base+= time_incr;
05900         s->time= s->time_base*s->avctx->time_base.den + time_increment;
05901         if(s->workaround_bugs&FF_BUG_UMP4){
05902             if(s->time < s->last_non_b_time){
05903 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
05904                 s->time_base++;
05905                 s->time+= s->avctx->time_base.den;
05906             }
05907         }
05908         s->pp_time= s->time - s->last_non_b_time;
05909         s->last_non_b_time= s->time;
05910     }else{
05911         s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
05912         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
05913         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
05914 //            printf("messed up order, maybe after seeking? skipping current b frame\n");
05915             return FRAME_SKIPPED;
05916         }
05917         ff_mpeg4_init_direct_mv(s);
05918 
05919         if(s->t_frame==0) s->t_frame= s->pb_time;
05920         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
05921         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
05922                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
05923         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
05924                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
05925         if(!s->progressive_sequence){
05926             if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
05927                 return FRAME_SKIPPED;
05928         }
05929     }
05930 //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);
05931 
05932     if(s->avctx->time_base.num)
05933         s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
05934     else
05935         s->current_picture_ptr->pts= AV_NOPTS_VALUE;
05936     if(s->avctx->debug&FF_DEBUG_PTS)
05937         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
05938 
05939     check_marker(gb, "before vop_coded");
05940 
05941     /* vop coded */
05942     if (get_bits1(gb) != 1){
05943         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
05944             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
05945         return FRAME_SKIPPED;
05946     }
05947 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
05948 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
05949     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE
05950                           || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
05951         /* rounding type for motion estimation */
05952         s->no_rounding = get_bits1(gb);
05953     } else {
05954         s->no_rounding = 0;
05955     }
05956 //FIXME reduced res stuff
05957 
05958      if (s->shape != RECT_SHAPE) {
05959          if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) {
05960              int width, height, hor_spat_ref, ver_spat_ref;
05961 
05962              width = get_bits(gb, 13);
05963              skip_bits1(gb);   /* marker */
05964              height = get_bits(gb, 13);
05965              skip_bits1(gb);   /* marker */
05966              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
05967              skip_bits1(gb);   /* marker */
05968              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
05969          }
05970          skip_bits1(gb); /* change_CR_disable */
05971 
05972          if (get_bits1(gb) != 0) {
05973              skip_bits(gb, 8); /* constant_alpha_value */
05974          }
05975      }
05976 //FIXME complexity estimation stuff
05977 
05978      if (s->shape != BIN_ONLY_SHAPE) {
05979          skip_bits_long(gb, s->cplx_estimation_trash_i);
05980          if(s->pict_type != FF_I_TYPE)
05981             skip_bits_long(gb, s->cplx_estimation_trash_p);
05982          if(s->pict_type == FF_B_TYPE)
05983             skip_bits_long(gb, s->cplx_estimation_trash_b);
05984 
05985          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
05986          if(!s->progressive_sequence){
05987              s->top_field_first= get_bits1(gb);
05988              s->alternate_scan= get_bits1(gb);
05989          }else
05990              s->alternate_scan= 0;
05991      }
05992 
05993      if(s->alternate_scan){
05994          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
05995          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
05996          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
05997          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
05998      } else{
05999          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
06000          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
06001          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
06002          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
06003      }
06004 
06005      if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
06006          mpeg4_decode_sprite_trajectory(s, gb);
06007          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
06008          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
06009      }
06010 
06011      if (s->shape != BIN_ONLY_SHAPE) {
06012          s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
06013          if(s->qscale==0){
06014              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
06015              return -1; // makes no sense to continue, as there is nothing left from the image then
06016          }
06017 
06018          if (s->pict_type != FF_I_TYPE) {
06019              s->f_code = get_bits(gb, 3);       /* fcode_for */
06020              if(s->f_code==0){
06021                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
06022                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
06023              }
06024          }else
06025              s->f_code=1;
06026 
06027          if (s->pict_type == FF_B_TYPE) {
06028              s->b_code = get_bits(gb, 3);
06029          }else
06030              s->b_code=1;
06031 
06032          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
06033              av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d\n",
06034                  s->qscale, s->f_code, s->b_code,
06035                  s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
06036                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
06037                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
06038                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold, s->cplx_estimation_trash_i, s->cplx_estimation_trash_p, s->cplx_estimation_trash_b);
06039          }
06040 
06041          if(!s->scalability){
06042              if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) {
06043                  skip_bits1(gb); // vop shape coding type
06044              }
06045          }else{
06046              if(s->enhancement_type){
06047                  int load_backward_shape= get_bits1(gb);
06048                  if(load_backward_shape){
06049                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
06050                  }
06051              }
06052              skip_bits(gb, 2); //ref_select_code
06053          }
06054      }
06055      /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
06056      // note we cannot detect divx5 without b-frames easily (although it's buggy too)
06057      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
06058          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
06059          s->low_delay=1;
06060      }
06061 
06062      s->picture_number++; // better than pic number==0 always ;)
06063 
06064      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
06065      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
06066 
06067      if(s->workaround_bugs&FF_BUG_EDGE){
06068          s->h_edge_pos= s->width;
06069          s->v_edge_pos= s->height;
06070      }
06071      return 0;
06072 }
06073 
06080 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
06081 {
06082     int startcode, v;
06083 
06084     /* search next start code */
06085     align_get_bits(gb);
06086 
06087     if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){
06088         skip_bits(gb, 24);
06089         if(get_bits(gb, 8) == 0xF0)
06090             goto end;
06091     }
06092 
06093     startcode = 0xff;
06094     for(;;) {
06095         if(get_bits_count(gb) >= gb->size_in_bits){
06096             if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
06097                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
06098                 return FRAME_SKIPPED; //divx bug
06099             }else
06100                 return -1; //end of stream
06101         }
06102 
06103         /* use the bits after the test */
06104         v = get_bits(gb, 8);
06105         startcode = ((startcode << 8) | v) & 0xffffffff;
06106 
06107         if((startcode&0xFFFFFF00) != 0x100)
06108             continue; //no startcode
06109 
06110         if(s->avctx->debug&FF_DEBUG_STARTCODE){
06111             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
06112             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
06113             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
06114             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
06115             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
06116             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
06117             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
06118             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
06119             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
06120             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
06121             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
06122             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
06123             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
06124             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
06125             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
06126             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
06127             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
06128             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
06129             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
06130             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
06131             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
06132             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
06133             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
06134             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
06135             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
06136             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
06137             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
06138             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
06139             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
06140         }
06141 
06142         if(startcode >= 0x120 && startcode <= 0x12F){
06143             if(decode_vol_header(s, gb) < 0)
06144                 return -1;
06145         }
06146         else if(startcode == USER_DATA_STARTCODE){
06147             decode_user_data(s, gb);
06148         }
06149         else if(startcode == GOP_STARTCODE){
06150             mpeg4_decode_gop_header(s, gb);
06151         }
06152         else if(startcode == VOP_STARTCODE){
06153             break;
06154         }
06155 
06156         align_get_bits(gb);
06157         startcode = 0xff;
06158     }
06159 end:
06160     if(s->flags& CODEC_FLAG_LOW_DELAY)
06161         s->low_delay=1;
06162     s->avctx->has_b_frames= !s->low_delay;
06163     return decode_vop_header(s, gb);
06164 }
06165 
06166 /* don't understand why they choose a different header ! */
06167 int intel_h263_decode_picture_header(MpegEncContext *s)
06168 {
06169     int format;
06170 
06171     /* picture header */
06172     if (get_bits_long(&s->gb, 22) != 0x20) {
06173         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
06174         return -1;
06175     }
06176     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
06177 
06178     if (get_bits1(&s->gb) != 1) {
06179         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
06180         return -1;      /* marker */
06181     }
06182     if (get_bits1(&s->gb) != 0) {
06183         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
06184         return -1;      /* h263 id */
06185     }
06186     skip_bits1(&s->gb);         /* split screen off */
06187     skip_bits1(&s->gb);         /* camera  off */
06188     skip_bits1(&s->gb);         /* freeze picture release off */
06189 
06190     format = get_bits(&s->gb, 3);
06191     if (format != 7) {
06192         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
06193         return -1;
06194     }
06195     s->h263_plus = 0;
06196 
06197     s->pict_type = FF_I_TYPE + get_bits1(&s->gb);
06198 
06199     s->unrestricted_mv = get_bits1(&s->gb);
06200     s->h263_long_vectors = s->unrestricted_mv;
06201 
06202     if (get_bits1(&s->gb) != 0) {
06203         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
06204         return -1;      /* SAC: off */
06205     }
06206     s->obmc= get_bits1(&s->gb);
06207     s->pb_frame = get_bits1(&s->gb);
06208 
06209     if(format == 7){
06210         format = get_bits(&s->gb, 3);
06211         if(format == 0 || format == 7){
06212             av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n");
06213             return -1;
06214         }
06215         if(get_bits(&s->gb, 2))
06216             av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
06217         s->loop_filter = get_bits1(&s->gb);
06218         if(get_bits1(&s->gb))
06219             av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
06220         if(get_bits1(&s->gb))
06221             s->pb_frame = 2;
06222         if(get_bits(&s->gb, 5))
06223             av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
06224         if(get_bits(&s->gb, 5) != 1)
06225             av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n");
06226     }
06227     if(format == 6){
06228         int ar = get_bits(&s->gb, 4);
06229         skip_bits(&s->gb, 9); // display width
06230         skip_bits1(&s->gb);
06231         skip_bits(&s->gb, 9); // display height
06232         if(ar == 15){
06233             skip_bits(&s->gb, 8); // aspect ratio - width
06234             skip_bits(&s->gb, 8); // aspect ratio - height
06235         }
06236     }
06237 
06238     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
06239     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
06240 
06241     if(s->pb_frame){
06242         skip_bits(&s->gb, 3); //temporal reference for B-frame
06243         skip_bits(&s->gb, 2); //dbquant
06244     }
06245 
06246     /* PEI */
06247     while (get_bits1(&s->gb) != 0) {
06248         skip_bits(&s->gb, 8);
06249     }
06250     s->f_code = 1;
06251 
06252     s->y_dc_scale_table=
06253     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
06254 
06255     if(s->avctx->debug&FF_DEBUG_PICT_INFO)
06256         show_pict_info(s);
06257 
06258     if(s->pb_frame){
06259         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
06260         return -1;      /* PB frame mode */
06261     }
06262     return 0;
06263 }
06264 
06265 int flv_h263_decode_picture_header(MpegEncContext *s)
06266 {
06267     int format, width, height;
06268 
06269     /* picture header */
06270     if (get_bits_long(&s->gb, 17) != 1) {
06271         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
06272         return -1;
06273     }
06274     format = get_bits(&s->gb, 5);
06275     if (format != 0 && format != 1) {
06276         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
06277         return -1;
06278     }
06279     s->h263_flv = format+1;
06280     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
06281     format = get_bits(&s->gb, 3);
06282     switch (format) {
06283     case 0:
06284         width = get_bits(&s->gb, 8);
06285         height = get_bits(&s->gb, 8);
06286         break;
06287     case 1:
06288         width = get_bits(&s->gb, 16);
06289         height = get_bits(&s->gb, 16);
06290         break;
06291     case 2:
06292         width = 352;
06293         height = 288;
06294         break;
06295     case 3:
06296         width = 176;
06297         height = 144;
06298         break;
06299     case 4:
06300         width = 128;
06301         height = 96;
06302         break;
06303     case 5:
06304         width = 320;
06305         height = 240;
06306         break;
06307     case 6:
06308         width = 160;
06309         height = 120;
06310         break;
06311     default:
06312         width = height = 0;
06313         break;
06314     }
06315     if(avcodec_check_dimensions(s->avctx, width, height))
06316         return -1;
06317     s->width = width;
06318     s->height = height;
06319 
06320     s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2);
06321     s->dropable= s->pict_type > FF_P_TYPE;
06322     if (s->dropable)
06323         s->pict_type = FF_P_TYPE;
06324 
06325     skip_bits1(&s->gb); /* deblocking flag */
06326     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
06327 
06328     s->h263_plus = 0;
06329 
06330     s->unrestricted_mv = 1;
06331     s->h263_long_vectors = 0;
06332 
06333     /* PEI */
06334     while (get_bits1(&s->gb) != 0) {
06335         skip_bits(&s->gb, 8);
06336     }
06337     s->f_code = 1;
06338 
06339     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
06340         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
06341                s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
06342     }
06343 
06344     s->y_dc_scale_table=
06345     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
06346 
06347     return 0;
06348 }

Generated on Tue Nov 4 2014 12:59:21 for ffmpeg by  doxygen 1.7.1