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