Cinelerra: hvirtual/quicktime/ffmpeg/libavcodec/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  * This library is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2 of the License, or (at your option) any later version.
00012  *
00013  * This library is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with this library; if not, write to the Free Software
00020  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00021  *
00022  * ac prediction encoding, b-frame support, error resilience, optimizations,
00023  * qpel decoding, gmc decoding, interlaced decoding, 
00024  * by Michael Niedermayer <michaelni@gmx.at>
00025  */
00026 
00032 //#define DEBUG
00033 #include <limits.h>
00034 
00035 #include "common.h"
00036 #include "dsputil.h"
00037 #include "avcodec.h"
00038 #include "mpegvideo.h"
00039 #include "h263data.h"
00040 #include "mpeg4data.h"
00041 
00042 //#undef NDEBUG
00043 //#include <assert.h>
00044 
00045 #define INTRA_MCBPC_VLC_BITS 6
00046 #define INTER_MCBPC_VLC_BITS 7
00047 #define CBPY_VLC_BITS 6
00048 #define MV_VLC_BITS 9
00049 #define DC_VLC_BITS 9
00050 #define SPRITE_TRAJ_VLC_BITS 6
00051 #define MB_TYPE_B_VLC_BITS 4
00052 #define TEX_VLC_BITS 9
00053 #define H263_MBTYPE_B_VLC_BITS 6
00054 #define CBPC_B_VLC_BITS 3
00055 
00056 #ifdef CONFIG_ENCODERS
00057 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
00058                               int n);
00059 static void h263p_encode_umotion(MpegEncContext * s, int val);
00060 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
00061                                int n, int dc, uint8_t *scan_table, 
00062                                PutBitContext *dc_pb, PutBitContext *ac_pb);
00063 #endif
00064 
00065 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
00066 static int h263p_decode_umotion(MpegEncContext * s, int pred);
00067 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
00068                              int n, int coded);
00069 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
00070 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
00071                               int n, int coded, int intra, int rvlc);
00072 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
00073                                uint8_t *scan_table);
00074 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
00075 #ifdef CONFIG_ENCODERS
00076 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
00077 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
00078 #endif //CONFIG_ENCODERS
00079 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
00080 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
00081 
00082 #ifdef CONFIG_ENCODERS
00083 static uint8_t uni_DCtab_lum_len[512];
00084 static uint8_t uni_DCtab_chrom_len[512];
00085 static uint16_t uni_DCtab_lum_bits[512];
00086 static uint16_t uni_DCtab_chrom_bits[512];
00087 
00088 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
00089 static uint8_t fcode_tab[MAX_MV*2+1];
00090 static uint8_t umv_fcode_tab[MAX_MV*2+1];
00091 
00092 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
00093 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
00094 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
00095 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
00096 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
00097 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
00098 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
00099 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
00100 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
00101 
00102 /* mpeg4
00103 inter
00104 max level: 24/6
00105 max run: 53/63
00106 
00107 intra
00108 max level: 53/16
00109 max run: 29/41
00110 */
00111 #endif
00112 
00113 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
00114 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
00115 #else 
00116 #define IS_3IV1 0
00117 #endif
00118 
00119 int h263_get_picture_format(int width, int height)
00120 {
00121     int format;
00122 
00123     if (width == 128 && height == 96)
00124         format = 1;
00125     else if (width == 176 && height == 144)
00126         format = 2;
00127     else if (width == 352 && height == 288)
00128         format = 3;
00129     else if (width == 704 && height == 576)
00130         format = 4;
00131     else if (width == 1408 && height == 1152)
00132         format = 5;
00133     else
00134         format = 7;
00135     return format;
00136 }
00137 
00138 #ifdef CONFIG_ENCODERS
00139 
00140 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
00141     int i;
00142 
00143     if(aspect.num==0) aspect= (AVRational){1,1};
00144 
00145     for(i=1; i<6; i++){
00146         if(av_cmp_q(pixel_aspect[i], aspect) == 0){
00147             s->aspect_ratio_info=i;
00148             return;
00149         }
00150     }
00151     
00152     s->aspect_ratio_info= FF_ASPECT_EXTENDED;
00153 }
00154 
00155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
00156 {
00157       int format;
00158 
00159       align_put_bits(&s->pb);
00160 
00161       put_bits(&s->pb, 17, 1);
00162       put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
00163       put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
00164                            s->avctx->time_base.den) & 0xff); /* TemporalReference */
00165       if (s->width == 352 && s->height == 288)
00166         format = 2;
00167       else if (s->width == 176 && s->height == 144)
00168         format = 3;
00169       else if (s->width == 128 && s->height == 96)
00170         format = 4;
00171       else if (s->width == 320 && s->height == 240)
00172         format = 5;
00173       else if (s->width == 160 && s->height == 120)
00174         format = 6;
00175       else if (s->width <= 255 && s->height <= 255)
00176         format = 0; /* use 1 byte width & height */
00177       else
00178         format = 1; /* use 2 bytes width & height */
00179       put_bits(&s->pb, 3, format); /* PictureSize */
00180       if (format == 0) {
00181         put_bits(&s->pb, 8, s->width);
00182         put_bits(&s->pb, 8, s->height);
00183       } else if (format == 1) {
00184         put_bits(&s->pb, 16, s->width);
00185         put_bits(&s->pb, 16, s->height);
00186       }
00187       put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
00188       put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
00189       put_bits(&s->pb, 5, s->qscale); /* Quantizer */
00190       put_bits(&s->pb, 1, 0); /* ExtraInformation */
00191 
00192       if(s->h263_aic){
00193         s->y_dc_scale_table= 
00194           s->c_dc_scale_table= ff_aic_dc_scale_table;
00195       }else{
00196         s->y_dc_scale_table=
00197           s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00198       }
00199 }
00200 
00201 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
00202 {
00203     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
00204     int best_clock_code=1;
00205     int best_divisor=60;
00206     int best_error= INT_MAX;
00207    
00208     if(s->h263_plus){
00209         for(i=0; i<2; i++){
00210             int div, error;
00211             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
00212             div= clip(1, div, 127);
00213             error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
00214             if(error < best_error){
00215                 best_error= error;
00216                 best_divisor= div;
00217                 best_clock_code= i;
00218             }
00219         }
00220     }
00221     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
00222     coded_frame_rate= 1800000;
00223     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
00224 
00225     align_put_bits(&s->pb);
00226 
00227     /* Update the pointer to last GOB */
00228     s->ptr_lastgob = pbBufPtr(&s->pb);
00229     put_bits(&s->pb, 22, 0x20); /* PSC */
00230     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
00231                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
00232     put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
00233 
00234     put_bits(&s->pb, 1, 1);     /* marker */
00235     put_bits(&s->pb, 1, 0);     /* h263 id */
00236     put_bits(&s->pb, 1, 0);     /* split screen off */
00237     put_bits(&s->pb, 1, 0);     /* camera  off */
00238     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
00239     
00240     format = h263_get_picture_format(s->width, s->height);
00241     if (!s->h263_plus) {
00242         /* H.263v1 */
00243         put_bits(&s->pb, 3, format);
00244         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
00245         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
00246         of H.263v1 UMV implies to check the predicted MV after
00247         calculation of the current MB to see if we're on the limits */
00248         put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
00249         put_bits(&s->pb, 1, 0); /* SAC: off */
00250         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
00251         put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
00252         put_bits(&s->pb, 5, s->qscale);
00253         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
00254     } else {
00255         int ufep=1;
00256         /* H.263v2 */
00257         /* H.263 Plus PTYPE */
00258         
00259         put_bits(&s->pb, 3, 7);
00260         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
00261         if (format == 7)
00262             put_bits(&s->pb,3,6); /* Custom Source Format */
00263         else
00264             put_bits(&s->pb, 3, format);
00265             
00266         put_bits(&s->pb,1, s->custom_pcf);
00267         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
00268         put_bits(&s->pb,1,0); /* SAC: off */
00269         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
00270         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
00271         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
00272         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
00273         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
00274         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
00275         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
00276         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
00277         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
00278         put_bits(&s->pb,3,0); /* Reserved */
00279                 
00280         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
00281                 
00282         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
00283         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
00284         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
00285         put_bits(&s->pb,2,0); /* Reserved */
00286         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
00287                 
00288         /* This should be here if PLUSPTYPE */
00289         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
00290                 
00291                 if (format == 7) {
00292             /* Custom Picture Format (CPFMT) */
00293             aspect_to_info(s, s->avctx->sample_aspect_ratio);
00294 
00295             put_bits(&s->pb,4,s->aspect_ratio_info);
00296             put_bits(&s->pb,9,(s->width >> 2) - 1);
00297             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
00298             put_bits(&s->pb,9,(s->height >> 2));
00299             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
00300                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
00301                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
00302             }
00303         }
00304         if(s->custom_pcf){
00305             if(ufep){
00306                 put_bits(&s->pb, 1, best_clock_code);
00307                 put_bits(&s->pb, 7, best_divisor);
00308             }
00309             put_bits(&s->pb, 2, (temp_ref>>8)&3);
00310         }
00311         
00312         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
00313         if (s->umvplus)
00314 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
00315 //FIXME check actual requested range
00316             put_bits(&s->pb,2,1); /* unlimited */
00317         if(s->h263_slice_structured)
00318             put_bits(&s->pb,2,0); /* no weird submodes */
00319 
00320         put_bits(&s->pb, 5, s->qscale);
00321     }
00322 
00323     put_bits(&s->pb, 1, 0);     /* no PEI */
00324 
00325     if(s->h263_slice_structured){
00326         put_bits(&s->pb, 1, 1);
00327         
00328         assert(s->mb_x == 0 && s->mb_y == 0);
00329         ff_h263_encode_mba(s);
00330 
00331         put_bits(&s->pb, 1, 1);
00332     }
00333 
00334     if(s->h263_aic){
00335          s->y_dc_scale_table= 
00336          s->c_dc_scale_table= ff_aic_dc_scale_table;
00337     }else{
00338         s->y_dc_scale_table=
00339         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00340     }
00341 }
00342 
00346 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
00347 {
00348     put_bits(&s->pb, 17, 1); /* GBSC */
00349 
00350     if(s->h263_slice_structured){
00351         put_bits(&s->pb, 1, 1);
00352 
00353         ff_h263_encode_mba(s);
00354 
00355         if(s->mb_num > 1583)
00356             put_bits(&s->pb, 1, 1);
00357         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
00358         put_bits(&s->pb, 1, 1);
00359         put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
00360     }else{
00361         int gob_number= mb_line / s->gob_index;
00362 
00363         put_bits(&s->pb, 5, gob_number); /* GN */
00364         put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
00365         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
00366     }
00367 }
00368 
00369 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
00370     int last=0;
00371     int j;
00372     int rate=0;
00373 
00374     for(j=1; j<=block_last_index; j++){
00375         const int index= scantable[j];
00376         int level= block[index];
00377         if(level){
00378             level+= 64;
00379             if((level&(~127)) == 0){
00380                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
00381                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
00382             }else
00383                 rate += s->ac_esc_length;
00384             level-= 64;
00385 
00386             last= j;
00387         }
00388     }
00389     
00390     return rate;
00391 }
00392 
00393 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00394 {
00395     int score= 0;
00396     int i, n;
00397     int8_t * const qscale_table= s->current_picture.qscale_table;
00398 
00399     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
00400     
00401     for(n=0; n<6; n++){
00402         int16_t *ac_val, *ac_val1;
00403         
00404         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
00405 
00406         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00407         ac_val1= ac_val;
00408         if(dir[n]){
00409             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00410             /* top prediction */
00411             ac_val-= s->block_wrap[n]*16;
00412             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00413                 /* same qscale */
00414                 for(i=1; i<8; i++){
00415                     const int level= block[n][s->dsp.idct_permutation[i   ]];
00416                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
00417                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
00418                     ac_val1[i+8]= level;
00419                 }
00420             }else{
00421                 /* different qscale, we must rescale */
00422                 for(i=1; i<8; i++){
00423                     const int level= block[n][s->dsp.idct_permutation[i   ]];
00424                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00425                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
00426                     ac_val1[i+8]= level;
00427                 }
00428             }
00429             st[n]= s->intra_h_scantable.permutated;
00430         }else{
00431             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00432             /* left prediction */
00433             ac_val-= 16;
00434             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00435                 /* same qscale */
00436                 for(i=1; i<8; i++){
00437                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
00438                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
00439                     ac_val1[i  ]= level;
00440                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
00441                 }
00442             }else{
00443                 /* different qscale, we must rescale */
00444                 for(i=1; i<8; i++){
00445                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
00446                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00447                     ac_val1[i  ]= level;
00448                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
00449                 }
00450             }
00451             st[n]= s->intra_v_scantable.permutated;
00452         }
00453 
00454         for(i=63; i>0; i--) //FIXME optimize
00455             if(block[n][ st[n][i] ]) break;
00456         s->block_last_index[n]= i;
00457 
00458         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
00459     }
00460 
00461     return score < 0;
00462 }
00463 
00464 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00465 {
00466     int i, n;
00467     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
00468 
00469     for(n=0; n<6; n++){
00470         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00471 
00472         st[n]= s->intra_scantable.permutated;
00473         if(dir[n]){
00474             /* top prediction */
00475             for(i=1; i<8; i++){
00476                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
00477             }
00478         }else{
00479             /* left prediction */
00480             for(i=1; i<8; i++){
00481                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
00482             }
00483         }
00484     }
00485 }
00486 
00490 void ff_clean_h263_qscales(MpegEncContext *s){
00491     int i;
00492     int8_t * const qscale_table= s->current_picture.qscale_table;
00493     
00494     for(i=1; i<s->mb_num; i++){
00495         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
00496             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
00497     }
00498     for(i=s->mb_num-2; i>=0; i--){
00499         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
00500             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
00501     }
00502 
00503     if(s->codec_id != CODEC_ID_H263P){
00504         for(i=1; i<s->mb_num; i++){
00505             int mb_xy= s->mb_index2xy[i];
00506         
00507             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
00508                 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
00509                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
00510             }
00511         }
00512     }
00513 }
00514 
00518 void ff_clean_mpeg4_qscales(MpegEncContext *s){
00519     int i;
00520     int8_t * const qscale_table= s->current_picture.qscale_table;
00521 
00522     ff_clean_h263_qscales(s);
00523     
00524     if(s->pict_type== B_TYPE){
00525         int odd=0;
00526         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
00527         
00528         for(i=0; i<s->mb_num; i++){
00529             int mb_xy= s->mb_index2xy[i];
00530             odd += qscale_table[mb_xy]&1;
00531         }
00532         
00533         if(2*odd > s->mb_num) odd=1;
00534         else                  odd=0;
00535         
00536         for(i=0; i<s->mb_num; i++){
00537             int mb_xy= s->mb_index2xy[i];
00538             if((qscale_table[mb_xy]&1) != odd)
00539                 qscale_table[mb_xy]++;
00540             if(qscale_table[mb_xy] > 31)
00541                 qscale_table[mb_xy]= 31;
00542         }            
00543     
00544         for(i=1; i<s->mb_num; i++){
00545             int mb_xy= s->mb_index2xy[i];
00546             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
00547                 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
00548                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
00549             }
00550         }
00551     }
00552 }
00553 
00554 #endif //CONFIG_ENCODERS
00555 
00559 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
00560     const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
00561     const int colocated_mb_type= s->next_picture.mb_type[mb_index];
00562     int xy= s->block_index[0];
00563     uint16_t time_pp= s->pp_time;
00564     uint16_t time_pb= s->pb_time;
00565     int i;
00566     
00567     //FIXME avoid divides
00568     
00569     if(IS_8X8(colocated_mb_type)){
00570         s->mv_type = MV_TYPE_8X8;
00571         for(i=0; i<4; i++){
00572             xy= s->block_index[i];
00573             s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
00574             s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
00575             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
00576                                 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
00577             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1] 
00578                                 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
00579         }
00580         return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
00581     } else if(IS_INTERLACED(colocated_mb_type)){
00582         s->mv_type = MV_TYPE_FIELD;
00583         for(i=0; i<2; i++){
00584             int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
00585             if(s->top_field_first){
00586                 time_pp= s->pp_field_time - field_select + i;
00587                 time_pb= s->pb_field_time - field_select + i;
00588             }else{
00589                 time_pp= s->pp_field_time + field_select - i;
00590                 time_pb= s->pb_field_time + field_select - i;
00591             }
00592             s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
00593             s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
00594             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
00595                                 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
00596             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 
00597                                 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
00598         }
00599         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
00600     }else{
00601         s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
00602         s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
00603         s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->next_picture.motion_val[0][xy][0]
00604                             : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
00605         s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->next_picture.motion_val[0][xy][1] 
00606                             : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
00607         if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
00608             s->mv_type= MV_TYPE_16X16;
00609         else
00610             s->mv_type= MV_TYPE_8X8;
00611         return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
00612     }
00613 }
00614 
00615 void ff_h263_update_motion_val(MpegEncContext * s){
00616     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
00617                //FIXME a lot of that is only needed for !low_delay
00618     const int wrap = s->b8_stride;
00619     const int xy = s->block_index[0];
00620     
00621     s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; 
00622 
00623     if(s->mv_type != MV_TYPE_8X8){
00624         int motion_x, motion_y;
00625         if (s->mb_intra) {
00626             motion_x = 0;
00627             motion_y = 0;
00628         } else if (s->mv_type == MV_TYPE_16X16) {
00629             motion_x = s->mv[0][0][0];
00630             motion_y = s->mv[0][0][1];
00631         } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
00632             int i;
00633             motion_x = s->mv[0][0][0] + s->mv[0][1][0];
00634             motion_y = s->mv[0][0][1] + s->mv[0][1][1];
00635             motion_x = (motion_x>>1) | (motion_x&1);
00636             for(i=0; i<2; i++){
00637                 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
00638                 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
00639             }
00640             s->current_picture.ref_index[0][xy           ]=
00641             s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
00642             s->current_picture.ref_index[0][xy + wrap    ]=
00643             s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
00644         }
00645 
00646         /* no update if 8X8 because it has been done during parsing */
00647         s->current_picture.motion_val[0][xy][0] = motion_x;
00648         s->current_picture.motion_val[0][xy][1] = motion_y;
00649         s->current_picture.motion_val[0][xy + 1][0] = motion_x;
00650         s->current_picture.motion_val[0][xy + 1][1] = motion_y;
00651         s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
00652         s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
00653         s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
00654         s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
00655     }
00656 
00657     if(s->encoding){ //FIXME encoding MUST be cleaned up
00658         if (s->mv_type == MV_TYPE_8X8) 
00659             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
00660         else if(s->mb_intra)
00661             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
00662         else
00663             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
00664     }
00665 }
00666 
00667 #ifdef CONFIG_ENCODERS
00668 
00669 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
00670     int l, bit_size, code;
00671 
00672     if (val == 0) {
00673         return mvtab[0][1];
00674     } else {
00675         bit_size = f_code - 1;
00676         /* modulo encoding */
00677         l= INT_BIT - 6 - bit_size;
00678         val = (val<<l)>>l;
00679         val--;
00680         code = (val >> bit_size) + 1;
00681 
00682         return mvtab[code][1] + 1 + bit_size;
00683     }
00684 }
00685 
00686 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
00687     if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00688         skip_put_bits(&s->pb, 
00689             h263_get_motion_length(s, x, f_code)
00690            +h263_get_motion_length(s, y, f_code));
00691     }else{
00692         ff_h263_encode_motion(s, x, f_code);
00693         ff_h263_encode_motion(s, y, f_code);
00694     }
00695 }
00696 
00697 static inline int get_p_cbp(MpegEncContext * s,
00698                       DCTELEM block[6][64],
00699                       int motion_x, int motion_y){
00700     int cbp, i;
00701 
00702     if(s->flags & CODEC_FLAG_CBP_RD){
00703         int best_cbpy_score= INT_MAX;
00704         int best_cbpc_score= INT_MAX;
00705         int cbpc = (-1), cbpy= (-1);
00706         const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
00707         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00708 
00709         for(i=0; i<4; i++){
00710             int score= inter_MCBPC_bits[i + offset] * lambda;
00711             if(i&1) score += s->coded_score[5];
00712             if(i&2) score += s->coded_score[4];
00713 
00714             if(score < best_cbpc_score){
00715                 best_cbpc_score= score;
00716                 cbpc= i;
00717             }
00718         }
00719 
00720         for(i=0; i<16; i++){
00721             int score= cbpy_tab[i ^ 0xF][1] * lambda;
00722             if(i&1) score += s->coded_score[3];
00723             if(i&2) score += s->coded_score[2];
00724             if(i&4) score += s->coded_score[1];
00725             if(i&8) score += s->coded_score[0];
00726 
00727             if(score < best_cbpy_score){
00728                 best_cbpy_score= score;
00729                 cbpy= i;
00730             }
00731         }
00732         cbp= cbpc + 4*cbpy;
00733         if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
00734             if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
00735                 cbp= 0;
00736         }
00737 
00738         for (i = 0; i < 6; i++) {
00739             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
00740                 s->block_last_index[i]= -1;
00741                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
00742             }
00743         }
00744     }else{
00745         cbp= 0;
00746         for (i = 0; i < 6; i++) {
00747             if (s->block_last_index[i] >= 0)
00748                 cbp |= 1 << (5 - i);
00749         }
00750     }
00751     return cbp;
00752 }
00753 
00754 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
00755                             int motion_x, int motion_y, int mb_type){
00756     int cbp=0, i;
00757 
00758     if(s->flags & CODEC_FLAG_CBP_RD){
00759         int score=0;
00760         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00761         
00762         for(i=0; i<6; i++){
00763             if(s->coded_score[i] < 0){
00764                 score += s->coded_score[i];
00765                 cbp |= 1 << (5 - i);
00766             }
00767         }
00768         
00769         if(cbp){
00770             int zero_score= -6;
00771             if ((motion_x | motion_y | s->dquant | mb_type) == 0){
00772                 zero_score-= 4; //2*MV + mb_type + cbp bit
00773             }
00774 
00775             zero_score*= lambda;
00776             if(zero_score <= score){
00777                 cbp=0;
00778             }
00779         }
00780 
00781         for (i = 0; i < 6; i++) {
00782             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
00783                 s->block_last_index[i]= -1;
00784                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
00785             }
00786         }
00787     }else{
00788         for (i = 0; i < 6; i++) {
00789             if (s->block_last_index[i] >= 0)
00790                 cbp |= 1 << (5 - i);
00791         }
00792     }
00793     return cbp;
00794 }
00795 
00796 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], 
00797                                uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
00798     int i;
00799     
00800     if(scan_table){
00801         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00802             for (i = 0; i < 6; i++) {
00803                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
00804             }
00805         }else{
00806             /* encode each block */
00807             for (i = 0; i < 6; i++) {
00808                 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
00809             }
00810         }
00811     }else{
00812         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00813             for (i = 0; i < 6; i++) {
00814                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
00815             }
00816         }else{
00817             /* encode each block */
00818             for (i = 0; i < 6; i++) {
00819                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
00820             }
00821         }
00822     }
00823 }
00824 
00825 void mpeg4_encode_mb(MpegEncContext * s,
00826                     DCTELEM block[6][64],
00827                     int motion_x, int motion_y)
00828 {
00829     int cbpc, cbpy, pred_x, pred_y;
00830     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
00831     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
00832     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
00833     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
00834     const int dquant_code[5]= {1,0,9,2,3};
00835     
00836     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00837     if (!s->mb_intra) {
00838         int i, cbp;
00839         
00840         if(s->pict_type==B_TYPE){
00841             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
00842             int mb_type=  mb_type_table[s->mv_dir];
00843 
00844             if(s->mb_x==0){
00845                 for(i=0; i<2; i++){
00846                     s->last_mv[i][0][0]= 
00847                     s->last_mv[i][0][1]= 
00848                     s->last_mv[i][1][0]= 
00849                     s->last_mv[i][1][1]= 0;
00850                 }
00851             }
00852             
00853             assert(s->dquant>=-2 && s->dquant<=2);
00854             assert((s->dquant&1)==0);
00855             assert(mb_type>=0);
00856 
00857             /* nothing to do if this MB was skipped in the next P Frame */
00858             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
00859                 s->skip_count++;
00860                 s->mv[0][0][0]= 
00861                 s->mv[0][0][1]= 
00862                 s->mv[1][0][0]= 
00863                 s->mv[1][0][1]= 0;
00864                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
00865                 s->qscale -= s->dquant;
00866 //                s->mb_skipped=1;
00867 
00868                 return;
00869             }
00870             
00871             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
00872             
00873             if ((cbp | motion_x | motion_y | mb_type) ==0) {
00874                 /* direct MB with MV={0,0} */
00875                 assert(s->dquant==0);
00876                 
00877                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
00878 
00879                 if(interleaved_stats){
00880                     s->misc_bits++;
00881                     s->last_bits++;
00882                 }
00883                 s->skip_count++;
00884                 return;
00885             }
00886             
00887             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
00888             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
00889             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
00890             if(cbp) put_bits(&s->pb, 6, cbp);
00891             
00892             if(cbp && mb_type){
00893                 if(s->dquant)
00894                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
00895                 else
00896                     put_bits(&s->pb, 1, 0);
00897             }else
00898                 s->qscale -= s->dquant;
00899             
00900             if(!s->progressive_sequence){
00901                 if(cbp)
00902                     put_bits(&s->pb, 1, s->interlaced_dct);
00903                 if(mb_type) // not direct mode
00904                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
00905             }
00906 
00907             if(interleaved_stats){
00908                 s->misc_bits+= get_bits_diff(s);
00909             }
00910 
00911             if(mb_type == 0){
00912                 assert(s->mv_dir & MV_DIRECT);
00913                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
00914                 s->b_count++;
00915                 s->f_count++;
00916             }else{
00917                 assert(mb_type > 0 && mb_type < 4);
00918                 if(s->mv_type != MV_TYPE_FIELD){
00919                     if(s->mv_dir & MV_DIR_FORWARD){
00920                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
00921                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
00922                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
00923                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
00924                         s->f_count++;
00925                     }
00926                     if(s->mv_dir & MV_DIR_BACKWARD){
00927                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
00928                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
00929                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
00930                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
00931                         s->b_count++;
00932                     }
00933                 }else{
00934                     if(s->mv_dir & MV_DIR_FORWARD){
00935                         put_bits(&s->pb, 1, s->field_select[0][0]);
00936                         put_bits(&s->pb, 1, s->field_select[0][1]);
00937                     }
00938                     if(s->mv_dir & MV_DIR_BACKWARD){
00939                         put_bits(&s->pb, 1, s->field_select[1][0]);
00940                         put_bits(&s->pb, 1, s->field_select[1][1]);
00941                     }
00942                     if(s->mv_dir & MV_DIR_FORWARD){
00943                         for(i=0; i<2; i++){
00944                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
00945                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
00946                             s->last_mv[0][i][0]= s->mv[0][i][0];
00947                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
00948                         }
00949                         s->f_count++;
00950                     }
00951                     if(s->mv_dir & MV_DIR_BACKWARD){
00952                         for(i=0; i<2; i++){
00953                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
00954                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
00955                             s->last_mv[1][i][0]= s->mv[1][i][0];
00956                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
00957                         }
00958                         s->b_count++;
00959                     }
00960                 }
00961             }
00962 
00963             if(interleaved_stats){
00964                 s->mv_bits+= get_bits_diff(s);
00965             }
00966 
00967             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
00968 
00969             if(interleaved_stats){
00970                 s->p_tex_bits+= get_bits_diff(s);
00971             }
00972 
00973         }else{ /* s->pict_type==B_TYPE */
00974             cbp= get_p_cbp(s, block, motion_x, motion_y);
00975         
00976             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
00977                 /* check if the B frames can skip it too, as we must skip it if we skip here 
00978                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
00979                 if(s->max_b_frames>0){
00980                     int i;
00981                     int x,y, offset;
00982                     uint8_t *p_pic;
00983 
00984                     x= s->mb_x*16;
00985                     y= s->mb_y*16;
00986                     if(x+16 > s->width)  x= s->width-16;
00987                     if(y+16 > s->height) y= s->height-16;
00988 
00989                     offset= x + y*s->linesize;
00990                     p_pic= s->new_picture.data[0] + offset;
00991                     
00992                     s->mb_skipped=1;
00993                     for(i=0; i<s->max_b_frames; i++){
00994                         uint8_t *b_pic;
00995                         int diff;
00996                         Picture *pic= s->reordered_input_picture[i+1];
00997 
00998                         if(pic==NULL || pic->pict_type!=B_TYPE) break;
00999 
01000                         b_pic= pic->data[0] + offset + 16; //FIXME +16
01001                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
01002                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
01003                             s->mb_skipped=0;
01004                             break;
01005                         }
01006                     }
01007                 }else
01008                     s->mb_skipped=1; 
01009 
01010                 if(s->mb_skipped==1){
01011                     /* skip macroblock */
01012                     put_bits(&s->pb, 1, 1);
01013 
01014                     if(interleaved_stats){
01015                         s->misc_bits++;
01016                         s->last_bits++;
01017                     }
01018                     s->skip_count++;
01019                     
01020                     return;
01021                 }
01022             }
01023 
01024             put_bits(&s->pb, 1, 0);     /* mb coded */
01025             cbpc = cbp & 3;
01026             cbpy = cbp >> 2;
01027             cbpy ^= 0xf;
01028             if(s->mv_type==MV_TYPE_16X16){
01029                 if(s->dquant) cbpc+= 8;
01030                 put_bits(&s->pb,
01031                         inter_MCBPC_bits[cbpc],
01032                         inter_MCBPC_code[cbpc]);
01033 
01034                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01035                 if(s->dquant)
01036                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
01037 
01038                 if(!s->progressive_sequence){
01039                     if(cbp)
01040                         put_bits(pb2, 1, s->interlaced_dct);
01041                     put_bits(pb2, 1, 0);
01042                 }
01043                     
01044                 if(interleaved_stats){
01045                     s->misc_bits+= get_bits_diff(s);
01046                 }
01047 
01048                 /* motion vectors: 16x16 mode */
01049                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01050             
01051                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01052                                                 motion_y - pred_y, s->f_code);
01053             }else if(s->mv_type==MV_TYPE_FIELD){
01054                 if(s->dquant) cbpc+= 8;
01055                 put_bits(&s->pb,
01056                         inter_MCBPC_bits[cbpc],
01057                         inter_MCBPC_code[cbpc]);
01058 
01059                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01060                 if(s->dquant)
01061                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
01062 
01063                 assert(!s->progressive_sequence);
01064                 if(cbp)
01065                     put_bits(pb2, 1, s->interlaced_dct);
01066                 put_bits(pb2, 1, 1);
01067                     
01068                 if(interleaved_stats){
01069                     s->misc_bits+= get_bits_diff(s);
01070                 }
01071 
01072                 /* motion vectors: 16x8 interlaced mode */
01073                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01074                 pred_y /=2;
01075                 
01076                 put_bits(&s->pb, 1, s->field_select[0][0]);
01077                 put_bits(&s->pb, 1, s->field_select[0][1]);
01078             
01079                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
01080                                                 s->mv[0][0][1] - pred_y, s->f_code);
01081                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
01082                                                 s->mv[0][1][1] - pred_y, s->f_code);
01083             }else{
01084                 assert(s->mv_type==MV_TYPE_8X8);
01085                 put_bits(&s->pb,
01086                         inter_MCBPC_bits[cbpc+16],
01087                         inter_MCBPC_code[cbpc+16]);
01088                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01089 
01090                 if(!s->progressive_sequence){
01091                     if(cbp)
01092                         put_bits(pb2, 1, s->interlaced_dct);
01093                 }
01094     
01095                 if(interleaved_stats){
01096                     s->misc_bits+= get_bits_diff(s);
01097                 }
01098 
01099                 for(i=0; i<4; i++){
01100                     /* motion vectors: 8x8 mode*/
01101                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01102 
01103                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
01104                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
01105                 }
01106             }
01107 
01108             if(interleaved_stats){ 
01109                 s->mv_bits+= get_bits_diff(s);
01110             }
01111 
01112             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
01113 
01114             if(interleaved_stats){
01115                 s->p_tex_bits+= get_bits_diff(s);
01116             }
01117             s->f_count++;
01118         }
01119     } else {
01120         int cbp;
01121         int dc_diff[6];   //dc values with the dc prediction subtracted 
01122         int dir[6];  //prediction direction
01123         int zigzag_last_index[6];
01124         uint8_t *scan_table[6];
01125         int i;
01126 
01127         for(i=0; i<6; i++){
01128             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
01129         }
01130 
01131         if(s->flags & CODEC_FLAG_AC_PRED){
01132             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
01133             if(!s->ac_pred)
01134                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
01135         }else{
01136             for(i=0; i<6; i++)
01137                 scan_table[i]= s->intra_scantable.permutated;
01138         }
01139 
01140         /* compute cbp */
01141         cbp = 0;
01142         for (i = 0; i < 6; i++) {
01143             if (s->block_last_index[i] >= 1)
01144                 cbp |= 1 << (5 - i);
01145         }
01146 
01147         cbpc = cbp & 3;
01148         if (s->pict_type == I_TYPE) {
01149             if(s->dquant) cbpc+=4;
01150             put_bits(&s->pb,
01151                 intra_MCBPC_bits[cbpc],
01152                 intra_MCBPC_code[cbpc]);
01153         } else {
01154             if(s->dquant) cbpc+=8;
01155             put_bits(&s->pb, 1, 0);     /* mb coded */
01156             put_bits(&s->pb,
01157                 inter_MCBPC_bits[cbpc + 4],
01158                 inter_MCBPC_code[cbpc + 4]);
01159         }
01160         put_bits(pb2, 1, s->ac_pred);
01161         cbpy = cbp >> 2;
01162         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01163         if(s->dquant)
01164             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
01165 
01166         if(!s->progressive_sequence){
01167             put_bits(dc_pb, 1, s->interlaced_dct);
01168         }
01169 
01170         if(interleaved_stats){
01171             s->misc_bits+= get_bits_diff(s);
01172         }
01173 
01174         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
01175 
01176         if(interleaved_stats){
01177             s->i_tex_bits+= get_bits_diff(s);
01178         }
01179         s->i_count++;
01180 
01181         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
01182         if(s->ac_pred)
01183             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
01184     }
01185 }
01186 
01187 void h263_encode_mb(MpegEncContext * s,
01188                     DCTELEM block[6][64],
01189                     int motion_x, int motion_y)
01190 {
01191     int cbpc, cbpy, i, cbp, pred_x, pred_y;
01192     int16_t pred_dc;
01193     int16_t rec_intradc[6];
01194     uint16_t *dc_ptr[6];
01195     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
01196     const int dquant_code[5]= {1,0,9,2,3};
01197            
01198     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
01199     if (!s->mb_intra) {
01200         /* compute cbp */
01201         cbp= get_p_cbp(s, block, motion_x, motion_y);
01202 
01203         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
01204             /* skip macroblock */
01205             put_bits(&s->pb, 1, 1);
01206             if(interleaved_stats){
01207                 s->misc_bits++;
01208                 s->last_bits++;
01209             }
01210             s->skip_count++;
01211 
01212             return;
01213         }
01214         put_bits(&s->pb, 1, 0); /* mb coded */
01215         
01216         cbpc = cbp & 3;
01217         cbpy = cbp >> 2;
01218         if(s->alt_inter_vlc==0 || cbpc!=3)
01219             cbpy ^= 0xF;
01220         if(s->dquant) cbpc+= 8;
01221         if(s->mv_type==MV_TYPE_16X16){
01222             put_bits(&s->pb,
01223                     inter_MCBPC_bits[cbpc],
01224                     inter_MCBPC_code[cbpc]);
01225 
01226             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01227             if(s->dquant)
01228                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01229                 
01230             if(interleaved_stats){
01231                 s->misc_bits+= get_bits_diff(s);
01232             }
01233 
01234             /* motion vectors: 16x16 mode */
01235             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01236             
01237             if (!s->umvplus) {  
01238                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01239                                                 motion_y - pred_y, 1);
01240             }
01241             else {
01242                 h263p_encode_umotion(s, motion_x - pred_x);
01243                 h263p_encode_umotion(s, motion_y - pred_y);
01244                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
01245                     /* To prevent Start Code emulation */
01246                     put_bits(&s->pb,1,1);
01247             }
01248         }else{
01249             put_bits(&s->pb,
01250                     inter_MCBPC_bits[cbpc+16],
01251                     inter_MCBPC_code[cbpc+16]);
01252             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01253             if(s->dquant)
01254                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01255 
01256             if(interleaved_stats){
01257                 s->misc_bits+= get_bits_diff(s);
01258             }
01259 
01260             for(i=0; i<4; i++){
01261                 /* motion vectors: 8x8 mode*/
01262                 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01263 
01264                 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
01265                 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
01266                 if (!s->umvplus) {  
01267                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
01268                                                     motion_y - pred_y, 1);
01269                 }
01270                 else {
01271                     h263p_encode_umotion(s, motion_x - pred_x);
01272                     h263p_encode_umotion(s, motion_y - pred_y);
01273                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
01274                         /* To prevent Start Code emulation */
01275                         put_bits(&s->pb,1,1);
01276                 }
01277             }
01278         }
01279 
01280         if(interleaved_stats){
01281             s->mv_bits+= get_bits_diff(s);
01282         }
01283     } else {
01284         assert(s->mb_intra);
01285         
01286         cbp = 0;
01287         if (s->h263_aic) {
01288             /* Predict DC */
01289             for(i=0; i<6; i++) {
01290                 int16_t level = block[i][0];
01291                 int scale;
01292                 
01293                 if(i<4) scale= s->y_dc_scale;
01294                 else    scale= s->c_dc_scale;
01295 
01296                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
01297                 level -= pred_dc;
01298                 /* Quant */
01299                 if (level >= 0)
01300                     level = (level + (scale>>1))/scale;
01301                 else
01302                     level = (level - (scale>>1))/scale;
01303                     
01304                 /* AIC can change CBP */
01305                 if (level == 0 && s->block_last_index[i] == 0)
01306                     s->block_last_index[i] = -1;
01307 
01308                 if(!s->modified_quant){
01309                     if (level < -127)
01310                         level = -127;
01311                     else if (level > 127)
01312                         level = 127;
01313                 }
01314 
01315                 block[i][0] = level;
01316                 /* Reconstruction */ 
01317                 rec_intradc[i] = scale*level + pred_dc;
01318                 /* Oddify */
01319                 rec_intradc[i] |= 1;
01320                 //if ((rec_intradc[i] % 2) == 0)
01321                 //    rec_intradc[i]++;
01322                 /* Clipping */
01323                 if (rec_intradc[i] < 0)
01324                     rec_intradc[i] = 0;
01325                 else if (rec_intradc[i] > 2047)
01326                     rec_intradc[i] = 2047;
01327                                 
01328                 /* Update AC/DC tables */
01329                 *dc_ptr[i] = rec_intradc[i];
01330                 if (s->block_last_index[i] >= 0)
01331                     cbp |= 1 << (5 - i);
01332             }
01333         }else{
01334             for(i=0; i<6; i++) {
01335                 /* compute cbp */
01336                 if (s->block_last_index[i] >= 1)
01337                     cbp |= 1 << (5 - i);
01338             }
01339         }
01340 
01341         cbpc = cbp & 3;
01342         if (s->pict_type == I_TYPE) {
01343             if(s->dquant) cbpc+=4;
01344             put_bits(&s->pb,
01345                 intra_MCBPC_bits[cbpc],
01346                 intra_MCBPC_code[cbpc]);
01347         } else {
01348             if(s->dquant) cbpc+=8;
01349             put_bits(&s->pb, 1, 0);     /* mb coded */
01350             put_bits(&s->pb,
01351                 inter_MCBPC_bits[cbpc + 4],
01352                 inter_MCBPC_code[cbpc + 4]);
01353         }
01354         if (s->h263_aic) {
01355             /* XXX: currently, we do not try to use ac prediction */
01356             put_bits(&s->pb, 1, 0);     /* no AC prediction */
01357         }
01358         cbpy = cbp >> 2;
01359         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01360         if(s->dquant)
01361             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01362 
01363         if(interleaved_stats){
01364             s->misc_bits+= get_bits_diff(s);
01365         }
01366     }
01367 
01368     for(i=0; i<6; i++) {
01369         /* encode each block */
01370         h263_encode_block(s, block[i], i);
01371     
01372         /* Update INTRADC for decoding */
01373         if (s->h263_aic && s->mb_intra) {
01374             block[i][0] = rec_intradc[i];
01375             
01376         }
01377     }
01378 
01379     if(interleaved_stats){
01380         if (!s->mb_intra) {
01381             s->p_tex_bits+= get_bits_diff(s);
01382             s->f_count++;
01383         }else{
01384             s->i_tex_bits+= get_bits_diff(s);
01385             s->i_count++;
01386         }
01387     }
01388 }
01389 #endif
01390 
01391 void ff_h263_loop_filter(MpegEncContext * s){
01392     int qp_c;
01393     const int linesize  = s->linesize;
01394     const int uvlinesize= s->uvlinesize;
01395     const int xy = s->mb_y * s->mb_stride + s->mb_x;
01396     uint8_t *dest_y = s->dest[0];
01397     uint8_t *dest_cb= s->dest[1];
01398     uint8_t *dest_cr= s->dest[2];
01399     
01400 //    if(s->pict_type==B_TYPE && !s->readable) return;
01401 
01402     /*
01403        Diag Top
01404        Left Center
01405     */
01406     if(!IS_SKIP(s->current_picture.mb_type[xy])){
01407         qp_c= s->qscale;
01408         s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
01409         s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
01410     }else
01411         qp_c= 0;
01412 
01413     if(s->mb_y){
01414         int qp_dt, qp_t, qp_tc;
01415 
01416         if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
01417             qp_t=0;
01418         else 
01419             qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
01420 
01421         if(qp_c) 
01422             qp_tc= qp_c;
01423         else
01424             qp_tc= qp_t;
01425             
01426         if(qp_tc){
01427             const int chroma_qp= s->chroma_qscale_table[qp_tc];
01428             s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
01429             s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
01430         
01431             s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
01432             s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
01433         }
01434         
01435         if(qp_t)
01436             s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
01437         
01438         if(s->mb_x){
01439             if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
01440                 qp_dt= qp_t;
01441             else
01442                 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
01443             
01444             if(qp_dt){
01445                 const int chroma_qp= s->chroma_qscale_table[qp_dt];
01446                 s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
01447                 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
01448                 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
01449             }
01450         }
01451     }
01452 
01453     if(qp_c){
01454         s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
01455         if(s->mb_y + 1 == s->mb_height)
01456             s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
01457     }
01458     
01459     if(s->mb_x){
01460         int qp_lc;
01461         if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
01462             qp_lc= qp_c;
01463         else
01464             qp_lc= s->current_picture.qscale_table[xy-1];
01465         
01466         if(qp_lc){
01467             s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
01468             if(s->mb_y + 1 == s->mb_height){
01469                 const int chroma_qp= s->chroma_qscale_table[qp_lc];
01470                 s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
01471                 s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
01472                 s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
01473             }
01474         }
01475     }
01476 }
01477 
01478 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
01479 {
01480     int x, y, wrap, a, c, pred_dc, scale;
01481     int16_t *dc_val, *ac_val;
01482 
01483     /* find prediction */
01484     if (n < 4) {
01485         x = 2 * s->mb_x + (n & 1);
01486         y = 2 * s->mb_y + ((n & 2) >> 1);
01487         wrap = s->b8_stride;
01488         dc_val = s->dc_val[0];
01489         ac_val = s->ac_val[0][0];
01490         scale = s->y_dc_scale;
01491     } else {
01492         x = s->mb_x;
01493         y = s->mb_y;
01494         wrap = s->mb_stride;
01495         dc_val = s->dc_val[n - 4 + 1];
01496         ac_val = s->ac_val[n - 4 + 1][0];
01497         scale = s->c_dc_scale;
01498     }
01499     /* B C
01500      * A X 
01501      */
01502     a = dc_val[(x - 1) + (y) * wrap];
01503     c = dc_val[(x) + (y - 1) * wrap];
01504     
01505     /* No prediction outside GOB boundary */
01506     if(s->first_slice_line && n!=3){
01507         if(n!=2) c= 1024;
01508         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
01509     }
01510     pred_dc = 1024;
01511     /* just DC prediction */
01512     if (a != 1024 && c != 1024)
01513         pred_dc = (a + c) >> 1;
01514     else if (a != 1024)
01515         pred_dc = a;
01516     else
01517         pred_dc = c;
01518     
01519     /* we assume pred is positive */
01520     //pred_dc = (pred_dc + (scale >> 1)) / scale;
01521     *dc_val_ptr = &dc_val[x + y * wrap];
01522     return pred_dc;
01523 }
01524 
01525 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
01526 {
01527     int x, y, wrap, a, c, pred_dc, scale, i;
01528     int16_t *dc_val, *ac_val, *ac_val1;
01529 
01530     /* find prediction */
01531     if (n < 4) {
01532         x = 2 * s->mb_x + (n & 1);
01533         y = 2 * s->mb_y + (n>> 1);
01534         wrap = s->b8_stride;
01535         dc_val = s->dc_val[0];
01536         ac_val = s->ac_val[0][0];
01537         scale = s->y_dc_scale;
01538     } else {
01539         x = s->mb_x;
01540         y = s->mb_y;
01541         wrap = s->mb_stride;
01542         dc_val = s->dc_val[n - 4 + 1];
01543         ac_val = s->ac_val[n - 4 + 1][0];
01544         scale = s->c_dc_scale;
01545     }
01546     
01547     ac_val += ((y) * wrap + (x)) * 16;
01548     ac_val1 = ac_val;
01549     
01550     /* B C
01551      * A X 
01552      */
01553     a = dc_val[(x - 1) + (y) * wrap];
01554     c = dc_val[(x) + (y - 1) * wrap];
01555     
01556     /* No prediction outside GOB boundary */
01557     if(s->first_slice_line && n!=3){
01558         if(n!=2) c= 1024;
01559         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
01560     }
01561     
01562     if (s->ac_pred) {
01563         pred_dc = 1024;
01564         if (s->h263_aic_dir) {
01565             /* left prediction */
01566             if (a != 1024) {
01567                 ac_val -= 16;
01568                 for(i=1;i<8;i++) {
01569                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
01570                 }
01571                 pred_dc = a;
01572             }
01573         } else {
01574             /* top prediction */
01575             if (c != 1024) {
01576                 ac_val -= 16 * wrap;
01577                 for(i=1;i<8;i++) {
01578                     block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
01579                 }
01580                 pred_dc = c;
01581             }
01582         }
01583     } else {
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     
01593     /* we assume pred is positive */
01594     block[0]=block[0]*scale + pred_dc;
01595     
01596     if (block[0] < 0)
01597         block[0] = 0;
01598     else 
01599         block[0] |= 1;
01600     
01601     /* Update AC/DC tables */
01602     dc_val[(x) + (y) * wrap] = block[0];
01603     
01604     /* left copy */
01605     for(i=1;i<8;i++)
01606         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
01607     /* top copy */
01608     for(i=1;i<8;i++)
01609         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
01610 }
01611 
01612 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
01613                         int *px, int *py)
01614 {
01615     int wrap;
01616     int16_t *A, *B, *C, (*mot_val)[2];
01617     static const int off[4]= {2, 1, 1, -1};
01618 
01619     wrap = s->b8_stride;
01620     mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
01621 
01622     A = mot_val[ - 1];
01623     /* special case for first (slice) line */
01624     if (s->first_slice_line && block<3) {
01625         // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
01626         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
01627         if(block==0){ //most common case
01628             if(s->mb_x  == s->resync_mb_x){ //rare
01629                 *px= *py = 0;
01630             }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
01631                 C = mot_val[off[block] - wrap];
01632                 if(s->mb_x==0){
01633                     *px = C[0];
01634                     *py = C[1];
01635                 }else{
01636                     *px = mid_pred(A[0], 0, C[0]);
01637                     *py = mid_pred(A[1], 0, C[1]);
01638                 }
01639             }else{
01640                 *px = A[0];
01641                 *py = A[1];
01642             }
01643         }else if(block==1){
01644             if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
01645                 C = mot_val[off[block] - wrap];
01646                 *px = mid_pred(A[0], 0, C[0]);
01647                 *py = mid_pred(A[1], 0, C[1]);
01648             }else{
01649                 *px = A[0];
01650                 *py = A[1];
01651             }
01652         }else{ /* block==2*/
01653             B = mot_val[ - wrap];
01654             C = mot_val[off[block] - wrap];
01655             if(s->mb_x == s->resync_mb_x) //rare
01656                 A[0]=A[1]=0;
01657     
01658             *px = mid_pred(A[0], B[0], C[0]);
01659             *py = mid_pred(A[1], B[1], C[1]);
01660         }
01661     } else {
01662         B = mot_val[ - wrap];
01663         C = mot_val[off[block] - wrap];
01664         *px = mid_pred(A[0], B[0], C[0]);
01665         *py = mid_pred(A[1], B[1], C[1]);
01666     }
01667     return *mot_val;
01668 }
01669 
01670 #ifdef CONFIG_ENCODERS
01671 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
01672 {
01673     int range, l, bit_size, sign, code, bits;
01674 
01675     if (val == 0) {
01676         /* zero vector */
01677         code = 0;
01678         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
01679     } else {
01680         bit_size = f_code - 1;
01681         range = 1 << bit_size;
01682         /* modulo encoding */
01683         l= INT_BIT - 6 - bit_size;
01684         val = (val<<l)>>l;
01685         sign = val>>31;
01686         val= (val^sign)-sign;
01687         sign&=1;
01688 
01689         val--;
01690         code = (val >> bit_size) + 1;
01691         bits = val & (range - 1);
01692 
01693         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
01694         if (bit_size > 0) {
01695             put_bits(&s->pb, bit_size, bits);
01696         }
01697     }
01698 }
01699 
01700 /* Encode MV differences on H.263+ with Unrestricted MV mode */
01701 static void h263p_encode_umotion(MpegEncContext * s, int val)
01702 {
01703     short sval = 0; 
01704     short i = 0;
01705     short n_bits = 0;
01706     short temp_val;
01707     int code = 0;
01708     int tcode;
01709     
01710     if ( val == 0)
01711         put_bits(&s->pb, 1, 1);
01712     else if (val == 1)
01713         put_bits(&s->pb, 3, 0);
01714     else if (val == -1)
01715         put_bits(&s->pb, 3, 2);
01716     else {
01717         
01718         sval = ((val < 0) ? (short)(-val):(short)val);
01719         temp_val = sval;
01720         
01721         while (temp_val != 0) {
01722             temp_val = temp_val >> 1;
01723             n_bits++;
01724         }
01725         
01726         i = n_bits - 1;
01727         while (i > 0) {
01728             tcode = (sval & (1 << (i-1))) >> (i-1);
01729             tcode = (tcode << 1) | 1;
01730             code = (code << 2) | tcode;
01731             i--;
01732         }
01733         code = ((code << 1) | (val < 0)) << 1;
01734         put_bits(&s->pb, (2*n_bits)+1, code);
01735         //printf("\nVal = %d\tCode = %d", sval, code);
01736     }
01737 }
01738 
01739 static void init_mv_penalty_and_fcode(MpegEncContext *s)
01740 {
01741     int f_code;
01742     int mv;
01743     
01744     if(mv_penalty==NULL)
01745         mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
01746     
01747     for(f_code=1; f_code<=MAX_FCODE; f_code++){
01748         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
01749             int len;
01750 
01751             if(mv==0) len= mvtab[0][1];
01752             else{
01753                 int val, bit_size, range, code;
01754 
01755                 bit_size = f_code - 1;
01756                 range = 1 << bit_size;
01757 
01758                 val=mv;
01759                 if (val < 0) 
01760                     val = -val;
01761                 val--;
01762                 code = (val >> bit_size) + 1;
01763                 if(code<33){
01764                     len= mvtab[code][1] + 1 + bit_size;
01765                 }else{
01766                     len= mvtab[32][1] + 2 + bit_size;
01767                 }
01768             }
01769 
01770             mv_penalty[f_code][mv+MAX_MV]= len;
01771         }
01772     }
01773 
01774     for(f_code=MAX_FCODE; f_code>0; f_code--){
01775         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
01776             fcode_tab[mv+MAX_MV]= f_code;
01777         }
01778     }
01779 
01780     for(mv=0; mv<MAX_MV*2+1; mv++){
01781         umv_fcode_tab[mv]= 1;
01782     }
01783 }
01784 #endif
01785 
01786 #ifdef CONFIG_ENCODERS
01787 
01788 static void init_uni_dc_tab(void)
01789 {
01790     int level, uni_code, uni_len;
01791 
01792     for(level=-256; level<256; level++){
01793         int size, v, l;
01794         /* find number of bits */
01795         size = 0;
01796         v = abs(level);
01797         while (v) {
01798             v >>= 1;
01799             size++;
01800         }
01801 
01802         if (level < 0)
01803             l= (-level) ^ ((1 << size) - 1);
01804         else
01805             l= level;
01806 
01807         /* luminance */
01808         uni_code= DCtab_lum[size][0];
01809         uni_len = DCtab_lum[size][1];
01810 
01811         if (size > 0) {
01812             uni_code<<=size; uni_code|=l;
01813             uni_len+=size;
01814             if (size > 8){
01815                 uni_code<<=1; uni_code|=1;
01816                 uni_len++;
01817             }
01818         }
01819         uni_DCtab_lum_bits[level+256]= uni_code;
01820         uni_DCtab_lum_len [level+256]= uni_len;
01821 
01822         /* chrominance */
01823         uni_code= DCtab_chrom[size][0];
01824         uni_len = DCtab_chrom[size][1];
01825         
01826         if (size > 0) {
01827             uni_code<<=size; uni_code|=l;
01828             uni_len+=size;
01829             if (size > 8){
01830                 uni_code<<=1; uni_code|=1;
01831                 uni_len++;
01832             }
01833         }
01834         uni_DCtab_chrom_bits[level+256]= uni_code;
01835         uni_DCtab_chrom_len [level+256]= uni_len;
01836 
01837     }
01838 }
01839 
01840 #endif //CONFIG_ENCODERS
01841 
01842 #ifdef CONFIG_ENCODERS
01843 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01844     int slevel, run, last;
01845     
01846     assert(MAX_LEVEL >= 64);
01847     assert(MAX_RUN   >= 63);
01848 
01849     for(slevel=-64; slevel<64; slevel++){
01850         if(slevel==0) continue;
01851         for(run=0; run<64; run++){
01852             for(last=0; last<=1; last++){
01853                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
01854                 int level= slevel < 0 ? -slevel : slevel;
01855                 int sign= slevel < 0 ? 1 : 0;
01856                 int bits, len, code;
01857                 int level1, run1;
01858                 
01859                 len_tab[index]= 100;
01860                      
01861                 /* ESC0 */
01862                 code= get_rl_index(rl, last, run, level);
01863                 bits= rl->table_vlc[code][0];
01864                 len=  rl->table_vlc[code][1];
01865                 bits=bits*2+sign; len++;
01866                 
01867                 if(code!=rl->n && len < len_tab[index]){
01868                     bits_tab[index]= bits;
01869                     len_tab [index]= len;
01870                 }
01871 #if 1
01872                 /* ESC1 */
01873                 bits= rl->table_vlc[rl->n][0];
01874                 len=  rl->table_vlc[rl->n][1];
01875                 bits=bits*2;    len++; //esc1
01876                 level1= level - rl->max_level[last][run];
01877                 if(level1>0){
01878                     code= get_rl_index(rl, last, run, level1);
01879                     bits<<= rl->table_vlc[code][1];
01880                     len  += rl->table_vlc[code][1];
01881                     bits += rl->table_vlc[code][0];
01882                     bits=bits*2+sign; len++;
01883                 
01884                     if(code!=rl->n && len < len_tab[index]){
01885                         bits_tab[index]= bits;
01886                         len_tab [index]= len;
01887                     }
01888                 }
01889 #endif 
01890 #if 1
01891                 /* ESC2 */
01892                 bits= rl->table_vlc[rl->n][0];
01893                 len=  rl->table_vlc[rl->n][1];
01894                 bits=bits*4+2;    len+=2; //esc2
01895                 run1 = run - rl->max_run[last][level] - 1;
01896                 if(run1>=0){
01897                     code= get_rl_index(rl, last, run1, level);
01898                     bits<<= rl->table_vlc[code][1];
01899                     len  += rl->table_vlc[code][1];
01900                     bits += rl->table_vlc[code][0];
01901                     bits=bits*2+sign; len++;
01902                 
01903                     if(code!=rl->n && len < len_tab[index]){
01904                         bits_tab[index]= bits;
01905                         len_tab [index]= len;
01906                     }
01907                 }
01908 #endif           
01909                 /* ESC3 */        
01910                 bits= rl->table_vlc[rl->n][0];
01911                 len = rl->table_vlc[rl->n][1];
01912                 bits=bits*4+3;    len+=2; //esc3
01913                 bits=bits*2+last; len++;
01914                 bits=bits*64+run; len+=6;
01915                 bits=bits*2+1;    len++;  //marker
01916                 bits=bits*4096+(slevel&0xfff); len+=12;
01917                 bits=bits*2+1;    len++;  //marker
01918                 
01919                 if(len < len_tab[index]){
01920                     bits_tab[index]= bits;
01921                     len_tab [index]= len;
01922                 }
01923             }
01924         }
01925     }
01926 }
01927 
01928 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01929     int slevel, run, last;
01930     
01931     assert(MAX_LEVEL >= 64);
01932     assert(MAX_RUN   >= 63);
01933 
01934     for(slevel=-64; slevel<64; slevel++){
01935         if(slevel==0) continue;
01936         for(run=0; run<64; run++){
01937             for(last=0; last<=1; last++){
01938                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
01939                 int level= slevel < 0 ? -slevel : slevel;
01940                 int sign= slevel < 0 ? 1 : 0;
01941                 int bits, len, code;
01942                 
01943                 len_tab[index]= 100;
01944                      
01945                 /* ESC0 */
01946                 code= get_rl_index(rl, last, run, level);
01947                 bits= rl->table_vlc[code][0];
01948                 len=  rl->table_vlc[code][1];
01949                 bits=bits*2+sign; len++;
01950                 
01951                 if(code!=rl->n && len < len_tab[index]){
01952                     if(bits_tab) bits_tab[index]= bits;
01953                     len_tab [index]= len;
01954                 }
01955                 /* ESC */
01956                 bits= rl->table_vlc[rl->n][0];
01957                 len = rl->table_vlc[rl->n][1];
01958                 bits=bits*2+last; len++;
01959                 bits=bits*64+run; len+=6;
01960                 bits=bits*256+(level&0xff); len+=8;
01961                 
01962                 if(len < len_tab[index]){
01963                     if(bits_tab) bits_tab[index]= bits;
01964                     len_tab [index]= len;
01965                 }
01966             }
01967         }
01968     }
01969 }
01970 
01971 void h263_encode_init(MpegEncContext *s)
01972 {
01973     static int done = 0;
01974 
01975     if (!done) {
01976         done = 1;
01977 
01978         init_uni_dc_tab();
01979 
01980         init_rl(&rl_inter, 1);
01981         init_rl(&rl_intra, 1);
01982         init_rl(&rl_intra_aic, 1);
01983         
01984         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
01985         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
01986 
01987         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
01988         init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
01989 
01990         init_mv_penalty_and_fcode(s);
01991     }
01992     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
01993     
01994     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
01995     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
01996     if(s->h263_aic){
01997         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
01998         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
01999     }
02000     s->ac_esc_length= 7+1+6+8;
02001 
02002     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
02003     switch(s->codec_id){
02004     case CODEC_ID_MPEG4:
02005         s->fcode_tab= fcode_tab;
02006         s->min_qcoeff= -2048;
02007         s->max_qcoeff=  2047;
02008         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
02009         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
02010         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
02011         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
02012         s->luma_dc_vlc_length= uni_DCtab_lum_len;
02013         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
02014         s->ac_esc_length= 7+2+1+6+1+12+1;
02015         s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
02016         s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
02017 
02018         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
02019 
02020             s->avctx->extradata= av_malloc(1024);
02021             init_put_bits(&s->pb, s->avctx->extradata, 1024);
02022             
02023             if(!(s->workaround_bugs & FF_BUG_MS))
02024                 mpeg4_encode_visual_object_header(s);
02025             mpeg4_encode_vol_header(s, 0, 0);
02026 
02027 //            ff_mpeg4_stuffing(&s->pb); ?
02028             flush_put_bits(&s->pb);
02029             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
02030         }
02031         
02032         break;
02033     case CODEC_ID_H263P:
02034         if(s->umvplus)
02035             s->fcode_tab= umv_fcode_tab;
02036         if(s->modified_quant){
02037             s->min_qcoeff= -2047;
02038             s->max_qcoeff=  2047;
02039         }else{
02040             s->min_qcoeff= -127;
02041             s->max_qcoeff=  127;
02042         }
02043         break;
02044         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 
02045     case CODEC_ID_FLV1:
02046         if (s->h263_flv > 1) {
02047             s->min_qcoeff= -1023;
02048             s->max_qcoeff=  1023;
02049         } else {
02050             s->min_qcoeff= -127;
02051             s->max_qcoeff=  127;
02052         }
02053         s->y_dc_scale_table=
02054         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
02055         break;
02056     default: //nothing needed - default table already set in mpegvideo.c
02057         s->min_qcoeff= -127;
02058         s->max_qcoeff=  127;
02059         s->y_dc_scale_table=
02060         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
02061     }
02062 }
02063 
02069 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
02070 {
02071     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
02072     RLTable *rl;
02073 
02074     rl = &rl_inter;
02075     if (s->mb_intra && !s->h263_aic) {
02076         /* DC coef */
02077         level = block[0];
02078         /* 255 cannot be represented, so we clamp */
02079         if (level > 254) {
02080             level = 254;
02081             block[0] = 254;
02082         }
02083         /* 0 cannot be represented also */
02084         else if (level < 1) {
02085             level = 1;
02086             block[0] = 1;
02087         }
02088         if (level == 128) //FIXME check rv10
02089             put_bits(&s->pb, 8, 0xff);
02090         else
02091             put_bits(&s->pb, 8, level);
02092         i = 1;
02093     } else {
02094         i = 0;
02095         if (s->h263_aic && s->mb_intra)
02096             rl = &rl_intra_aic;
02097             
02098         if(s->alt_inter_vlc && !s->mb_intra){
02099             int aic_vlc_bits=0;
02100             int inter_vlc_bits=0;
02101             int wrong_pos=-1;
02102             int aic_code;
02103             
02104             last_index = s->block_last_index[n];
02105             last_non_zero = i - 1;
02106             for (; i <= last_index; i++) {
02107                 j = s->intra_scantable.permutated[i];
02108                 level = block[j];
02109                 if (level) {
02110                     run = i - last_non_zero - 1;
02111                     last = (i == last_index);
02112                     
02113                     if(level<0) level= -level;
02114                 
02115                     code = get_rl_index(rl, last, run, level);
02116                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
02117                     inter_vlc_bits += rl->table_vlc[code][1]+1;
02118                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
02119 
02120                     if (code == rl->n) {
02121                         inter_vlc_bits += 1+6+8-1;
02122                     }                
02123                     if (aic_code == rl_intra_aic.n) {
02124                         aic_vlc_bits += 1+6+8-1;
02125                         wrong_pos += run + 1;
02126                     }else
02127                         wrong_pos += wrong_run[aic_code];
02128                     last_non_zero = i;
02129                 }    
02130             }
02131             i = 0;
02132             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
02133                 rl = &rl_intra_aic;
02134         }
02135     }
02136    
02137     /* AC coefs */
02138     last_index = s->block_last_index[n];
02139     last_non_zero = i - 1;
02140     for (; i <= last_index; i++) {
02141         j = s->intra_scantable.permutated[i];
02142         level = block[j];
02143         if (level) {
02144             run = i - last_non_zero - 1;
02145             last = (i == last_index);
02146             sign = 0;
02147             slevel = level;
02148             if (level < 0) {
02149                 sign = 1;
02150                 level = -level;
02151             }
02152             code = get_rl_index(rl, last, run, level);
02153             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02154             if (code == rl->n) {
02155               if(s->h263_flv <= 1){
02156                 put_bits(&s->pb, 1, last);
02157                 put_bits(&s->pb, 6, run);
02158                 
02159                 assert(slevel != 0);
02160 
02161                 if(level < 128) 
02162                     put_bits(&s->pb, 8, slevel & 0xff);
02163                 else{
02164                     put_bits(&s->pb, 8, 128);
02165                     put_bits(&s->pb, 5, slevel & 0x1f);
02166                     put_bits(&s->pb, 6, (slevel>>5)&0x3f);
02167                 }
02168               }else{
02169                 if(level < 64) { // 7-bit level
02170                         put_bits(&s->pb, 1, 0);
02171                         put_bits(&s->pb, 1, last);
02172                         put_bits(&s->pb, 6, run);
02173 
02174                         put_bits(&s->pb, 7, slevel & 0x7f);
02175                     } else {
02176                         /* 11-bit level */
02177                         put_bits(&s->pb, 1, 1);
02178                         put_bits(&s->pb, 1, last);
02179                         put_bits(&s->pb, 6, run);
02180 
02181                         put_bits(&s->pb, 11, slevel & 0x7ff);
02182                     }
02183               }
02184             } else {
02185                 put_bits(&s->pb, 1, sign);
02186             }
02187             last_non_zero = i;
02188         }
02189     }
02190 }
02191 #endif
02192 
02193 #ifdef CONFIG_ENCODERS
02194 
02195 /***************************************************/
02199 void ff_mpeg4_stuffing(PutBitContext * pbc)
02200 {
02201     int length;
02202     put_bits(pbc, 1, 0);
02203     length= (-put_bits_count(pbc))&7;
02204     if(length) put_bits(pbc, length, (1<<length)-1);
02205 }
02206 
02207 /* must be called before writing the header */
02208 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
02209     int time_div, time_mod;
02210 
02211     assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
02212     s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
02213 
02214     time_div= s->time/s->avctx->time_base.den;
02215     time_mod= s->time%s->avctx->time_base.den;
02216 
02217     if(s->pict_type==B_TYPE){
02218         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
02219         assert(s->pb_time > 0 && s->pb_time < s->pp_time);
02220     }else{
02221         s->last_time_base= s->time_base;
02222         s->time_base= time_div;
02223         s->pp_time= s->time - s->last_non_b_time;
02224         s->last_non_b_time= s->time;
02225         assert(picture_number==0 || s->pp_time > 0);
02226     }
02227 }
02228 
02229 static void mpeg4_encode_gop_header(MpegEncContext * s){
02230     int hours, minutes, seconds;
02231     int64_t time;
02232     
02233     put_bits(&s->pb, 16, 0);
02234     put_bits(&s->pb, 16, GOP_STARTCODE);
02235     
02236     time= s->current_picture_ptr->pts;
02237     if(s->reordered_input_picture[1])
02238         time= FFMIN(time, s->reordered_input_picture[1]->pts);
02239     time= time*s->avctx->time_base.num;
02240 
02241     seconds= time/s->avctx->time_base.den;
02242     minutes= seconds/60; seconds %= 60;
02243     hours= minutes/60; minutes %= 60;
02244     hours%=24;
02245 
02246     put_bits(&s->pb, 5, hours);
02247     put_bits(&s->pb, 6, minutes);
02248     put_bits(&s->pb, 1, 1);
02249     put_bits(&s->pb, 6, seconds);
02250     
02251     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 
02252     put_bits(&s->pb, 1, 0); //broken link == NO
02253     
02254     s->last_time_base= time / s->avctx->time_base.den; 
02255 
02256     ff_mpeg4_stuffing(&s->pb);
02257 }
02258 
02259 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
02260     int profile_and_level_indication;
02261     int vo_ver_id;
02262     
02263     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
02264         profile_and_level_indication = s->avctx->profile << 4;
02265     }else if(s->max_b_frames || s->quarter_sample){
02266         profile_and_level_indication= 0xF0; // adv simple
02267     }else{
02268         profile_and_level_indication= 0x00; // simple
02269     }
02270 
02271     if(s->avctx->level != FF_LEVEL_UNKNOWN){
02272         profile_and_level_indication |= s->avctx->level;
02273     }else{
02274         profile_and_level_indication |= 1; //level 1
02275     }
02276 
02277     if(profile_and_level_indication>>4 == 0xF){
02278         vo_ver_id= 5;
02279     }else{
02280         vo_ver_id= 1;
02281     }
02282 
02283     //FIXME levels
02284 
02285     put_bits(&s->pb, 16, 0);
02286     put_bits(&s->pb, 16, VOS_STARTCODE);
02287 
02288     put_bits(&s->pb, 8, profile_and_level_indication);
02289 
02290     put_bits(&s->pb, 16, 0);
02291     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
02292     
02293     put_bits(&s->pb, 1, 1);
02294         put_bits(&s->pb, 4, vo_ver_id);
02295         put_bits(&s->pb, 3, 1); //priority
02296  
02297     put_bits(&s->pb, 4, 1); //visual obj type== video obj
02298     
02299     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
02300 
02301     ff_mpeg4_stuffing(&s->pb);
02302 }
02303 
02304 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
02305 {
02306     int vo_ver_id;
02307 
02308     if(s->max_b_frames || s->quarter_sample){
02309         vo_ver_id= 5;
02310         s->vo_type= ADV_SIMPLE_VO_TYPE;
02311     }else{
02312         vo_ver_id= 1;
02313         s->vo_type= SIMPLE_VO_TYPE;
02314     }
02315 
02316     put_bits(&s->pb, 16, 0);
02317     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
02318     put_bits(&s->pb, 16, 0);
02319     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
02320 
02321     put_bits(&s->pb, 1, 0);             /* random access vol */
02322     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
02323     if(s->workaround_bugs & FF_BUG_MS) {
02324         put_bits(&s->pb, 1, 0);        /* is obj layer id= no */
02325     } else {
02326         put_bits(&s->pb, 1, 1);        /* is obj layer id= yes */
02327         put_bits(&s->pb, 4, vo_ver_id);    /* is obj layer ver id */
02328         put_bits(&s->pb, 3, 1);        /* is obj layer priority */
02329     }
02330     
02331     aspect_to_info(s, s->avctx->sample_aspect_ratio);
02332 
02333     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
02334     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
02335         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
02336         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
02337     }
02338 
02339     if(s->workaround_bugs & FF_BUG_MS) { //
02340         put_bits(&s->pb, 1, 0);        /* vol control parameters= no @@@ */
02341     } else {
02342         put_bits(&s->pb, 1, 1);        /* vol control parameters= yes */
02343         put_bits(&s->pb, 2, 1);        /* chroma format YUV 420/YV12 */
02344         put_bits(&s->pb, 1, s->low_delay);
02345         put_bits(&s->pb, 1, 0);        /* vbv parameters= no */
02346     }
02347 
02348     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
02349     put_bits(&s->pb, 1, 1);             /* marker bit */
02350     
02351     put_bits(&s->pb, 16, s->avctx->time_base.den);
02352     if (s->time_increment_bits < 1)
02353         s->time_increment_bits = 1;
02354     put_bits(&s->pb, 1, 1);             /* marker bit */
02355     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
02356     put_bits(&s->pb, 1, 1);             /* marker bit */
02357     put_bits(&s->pb, 13, s->width);     /* vol width */
02358     put_bits(&s->pb, 1, 1);             /* marker bit */
02359     put_bits(&s->pb, 13, s->height);    /* vol height */
02360     put_bits(&s->pb, 1, 1);             /* marker bit */
02361     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
02362     put_bits(&s->pb, 1, 1);             /* obmc disable */
02363     if (vo_ver_id == 1) {
02364         put_bits(&s->pb, 1, s->vol_sprite_usage);               /* sprite enable */
02365     }else{
02366         put_bits(&s->pb, 2, s->vol_sprite_usage);               /* sprite enable */
02367     }
02368     
02369     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
02370     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
02371 
02372     if(s->mpeg_quant){
02373         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
02374         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
02375     }
02376 
02377     if (vo_ver_id != 1)
02378         put_bits(&s->pb, 1, s->quarter_sample);
02379     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
02380     s->resync_marker= s->rtp_mode;
02381     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
02382     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
02383     if(s->data_partitioning){
02384         put_bits(&s->pb, 1, 0);         /* no rvlc */
02385     }
02386 
02387     if (vo_ver_id != 1){
02388         put_bits(&s->pb, 1, 0);         /* newpred */
02389         put_bits(&s->pb, 1, 0);         /* reduced res vop */
02390     }
02391     put_bits(&s->pb, 1, 0);             /* scalability */
02392     
02393     ff_mpeg4_stuffing(&s->pb);
02394 
02395     /* user data */
02396     if(!(s->flags & CODEC_FLAG_BITEXACT)){
02397         put_bits(&s->pb, 16, 0);
02398         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
02399         put_string(&s->pb, LIBAVCODEC_IDENT, 0);
02400     }
02401 }
02402 
02403 /* write mpeg4 VOP header */
02404 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
02405 {
02406     int time_incr;
02407     int time_div, time_mod;
02408     
02409     if(s->pict_type==I_TYPE){
02410         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
02411             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
02412                 mpeg4_encode_visual_object_header(s);
02413             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
02414                 mpeg4_encode_vol_header(s, 0, 0);
02415         }
02416         if(!(s->workaround_bugs & FF_BUG_MS))
02417             mpeg4_encode_gop_header(s);
02418     }
02419     
02420     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
02421 
02422 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
02423     
02424     put_bits(&s->pb, 16, 0);            /* vop header */
02425     put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
02426     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
02427 
02428     assert(s->time>=0);
02429     time_div= s->time/s->avctx->time_base.den;
02430     time_mod= s->time%s->avctx->time_base.den;
02431     time_incr= time_div - s->last_time_base;
02432     assert(time_incr >= 0);
02433     while(time_incr--)
02434         put_bits(&s->pb, 1, 1);
02435         
02436     put_bits(&s->pb, 1, 0);
02437 
02438     put_bits(&s->pb, 1, 1);     /* marker */
02439     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
02440     put_bits(&s->pb, 1, 1);     /* marker */
02441     put_bits(&s->pb, 1, 1);     /* vop coded */
02442     if (    s->pict_type == P_TYPE 
02443         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
02444         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
02445     }
02446     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
02447     if(!s->progressive_sequence){
02448          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
02449          put_bits(&s->pb, 1, s->alternate_scan);
02450     }
02451     //FIXME sprite stuff
02452 
02453     put_bits(&s->pb, 5, s->qscale);
02454 
02455     if (s->pict_type != I_TYPE)
02456         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
02457     if (s->pict_type == B_TYPE)
02458         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
02459     //    printf("****frame %d\n", picture_number);
02460 }
02461 
02462 #endif //CONFIG_ENCODERS
02463 
02467 void ff_set_qscale(MpegEncContext * s, int qscale)
02468 {
02469     if (qscale < 1)
02470         qscale = 1;
02471     else if (qscale > 31)
02472         qscale = 31;
02473         
02474     s->qscale = qscale;
02475     s->chroma_qscale= s->chroma_qscale_table[qscale];
02476 
02477     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
02478     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
02479 }
02480 
02488 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
02489 {
02490     int a, b, c, wrap, pred, scale, ret;
02491     uint16_t *dc_val;
02492 
02493     /* find prediction */
02494     if (n < 4) {
02495         scale = s->y_dc_scale;
02496     } else {
02497         scale = s->c_dc_scale;
02498     }
02499     if(IS_3IV1)
02500         scale= 8;
02501 
02502     wrap= s->block_wrap[n];
02503     dc_val = s->dc_val[0] + s->block_index[n];
02504 
02505     /* B C
02506      * A X 
02507      */
02508     a = dc_val[ - 1];
02509     b = dc_val[ - 1 - wrap];
02510     c = dc_val[ - wrap];
02511 
02512     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
02513     if(s->first_slice_line && n!=3){
02514         if(n!=2) b=c= 1024;
02515         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
02516     }
02517     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
02518         if(n==0 || n==4 || n==5)
02519             b=1024;
02520     }
02521 
02522     if (abs(a - b) < abs(b - c)) {
02523         pred = c;
02524         *dir_ptr = 1; /* top */
02525     } else {
02526         pred = a;
02527         *dir_ptr = 0; /* left */
02528     }
02529     /* we assume pred is positive */
02530     pred = FASTDIV((pred + (scale >> 1)), scale);
02531 
02532     if(encoding){
02533         ret = level - pred;
02534     }else{
02535         level += pred;
02536         ret= level;
02537         if(s->error_resilience>=3){
02538             if(level<0){
02539                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
02540                 return -1;
02541             }
02542             if(level*scale > 2048 + scale){
02543                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
02544                 return -1;
02545             }
02546         }
02547     }
02548     level *=scale;
02549     if(level&(~2047)){
02550         if(level<0) 
02551             level=0;
02552         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
02553             level=2047;
02554     }
02555     dc_val[0]= level;
02556 
02557     return ret;
02558 }
02559 
02565 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
02566                    int dir)
02567 {
02568     int i;
02569     int16_t *ac_val, *ac_val1;
02570     int8_t * const qscale_table= s->current_picture.qscale_table;
02571 
02572     /* find prediction */
02573     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02574     ac_val1 = ac_val;
02575     if (s->ac_pred) {
02576         if (dir == 0) {
02577             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
02578             /* left prediction */
02579             ac_val -= 16;
02580             
02581             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
02582                 /* same qscale */
02583                 for(i=1;i<8;i++) {
02584                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
02585                 }
02586             }else{
02587                 /* different qscale, we must rescale */
02588                 for(i=1;i<8;i++) {
02589                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
02590                 }
02591             }
02592         } else {
02593             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
02594             /* top prediction */
02595             ac_val -= 16 * s->block_wrap[n];
02596 
02597             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
02598                 /* same qscale */
02599                 for(i=1;i<8;i++) {
02600                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
02601                 }
02602             }else{
02603                 /* different qscale, we must rescale */
02604                 for(i=1;i<8;i++) {
02605                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
02606                 }
02607             }
02608         }
02609     }
02610     /* left copy */
02611     for(i=1;i<8;i++)
02612         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
02613 
02614     /* top copy */
02615     for(i=1;i<8;i++)
02616         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
02617 
02618 }
02619 
02620 #ifdef CONFIG_ENCODERS
02621 
02626 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
02627 {
02628 #if 1
02629 //    if(level<-255 || level>255) printf("dc overflow\n");
02630     level+=256;
02631     if (n < 4) {
02632         /* luminance */
02633         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
02634     } else {
02635         /* chrominance */
02636         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
02637     }
02638 #else
02639     int size, v;
02640     /* find number of bits */
02641     size = 0;
02642     v = abs(level);
02643     while (v) {
02644         v >>= 1;
02645         size++;
02646     }
02647 
02648     if (n < 4) {
02649         /* luminance */
02650         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
02651     } else {
02652         /* chrominance */
02653         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
02654     }
02655 
02656     /* encode remaining bits */
02657     if (size > 0) {
02658         if (level < 0)
02659             level = (-level) ^ ((1 << size) - 1);
02660         put_bits(&s->pb, size, level);
02661         if (size > 8)
02662             put_bits(&s->pb, 1, 1);
02663     }
02664 #endif
02665 }
02666 
02667 static inline int mpeg4_get_dc_length(int level, int n){
02668     if (n < 4) {
02669         return uni_DCtab_lum_len[level + 256];
02670     } else {
02671         return uni_DCtab_chrom_len[level + 256];
02672     }
02673 }
02674 
02679 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
02680                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
02681 {
02682     int i, last_non_zero;
02683 #if 0 //variables for the outcommented version
02684     int code, sign, last;
02685 #endif
02686     const RLTable *rl;
02687     uint32_t *bits_tab;
02688     uint8_t *len_tab;
02689     const int last_index = s->block_last_index[n];
02690 
02691     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
02692         /* mpeg4 based DC predictor */
02693         mpeg4_encode_dc(dc_pb, intra_dc, n);
02694         if(last_index<1) return;
02695         i = 1;
02696         rl = &rl_intra;
02697         bits_tab= uni_mpeg4_intra_rl_bits;
02698         len_tab = uni_mpeg4_intra_rl_len;
02699     } else {
02700         if(last_index<0) return;
02701         i = 0;
02702         rl = &rl_inter;
02703         bits_tab= uni_mpeg4_inter_rl_bits;
02704         len_tab = uni_mpeg4_inter_rl_len;
02705     }
02706 
02707     /* AC coefs */
02708     last_non_zero = i - 1;
02709 #if 1
02710     for (; i < last_index; i++) {
02711         int level = block[ scan_table[i] ];
02712         if (level) {
02713             int run = i - last_non_zero - 1;
02714             level+=64;
02715             if((level&(~127)) == 0){
02716                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
02717                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
02718             }else{ //ESC3
02719                 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);
02720             }
02721             last_non_zero = i;
02722         }
02723     }
02724     /*if(i<=last_index)*/{
02725         int level = block[ scan_table[i] ];
02726         int run = i - last_non_zero - 1;
02727         level+=64;
02728         if((level&(~127)) == 0){
02729             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
02730             put_bits(ac_pb, len_tab[index], bits_tab[index]);
02731         }else{ //ESC3
02732             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);
02733         }
02734     }
02735 #else
02736     for (; i <= last_index; i++) {
02737         const int slevel = block[ scan_table[i] ];
02738         if (slevel) {
02739             int level;
02740             int run = i - last_non_zero - 1;
02741             last = (i == last_index);
02742             sign = 0;
02743             level = slevel;
02744             if (level < 0) {
02745                 sign = 1;
02746                 level = -level;
02747             }
02748             code = get_rl_index(rl, last, run, level);
02749             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02750             if (code == rl->n) {
02751                 int level1, run1;
02752                 level1 = level - rl->max_level[last][run];
02753                 if (level1 < 1) 
02754                     goto esc2;
02755                 code = get_rl_index(rl, last, run, level1);
02756                 if (code == rl->n) {
02757                 esc2:
02758                     put_bits(ac_pb, 1, 1);
02759                     if (level > MAX_LEVEL)
02760                         goto esc3;
02761                     run1 = run - rl->max_run[last][level] - 1;
02762                     if (run1 < 0)
02763                         goto esc3;
02764                     code = get_rl_index(rl, last, run1, level);
02765                     if (code == rl->n) {
02766                     esc3:
02767                         /* third escape */
02768                         put_bits(ac_pb, 1, 1);
02769                         put_bits(ac_pb, 1, last);
02770                         put_bits(ac_pb, 6, run);
02771                         put_bits(ac_pb, 1, 1);
02772                         put_bits(ac_pb, 12, slevel & 0xfff);
02773                         put_bits(ac_pb, 1, 1);
02774                     } else {
02775                         /* second escape */
02776                         put_bits(ac_pb, 1, 0);
02777                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02778                         put_bits(ac_pb, 1, sign);
02779                     }
02780                 } else {
02781                     /* first escape */
02782                     put_bits(ac_pb, 1, 0);
02783                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02784                     put_bits(ac_pb, 1, sign);
02785                 }
02786             } else {
02787                 put_bits(ac_pb, 1, sign);
02788             }
02789             last_non_zero = i;
02790         }
02791     }
02792 #endif
02793 }
02794 
02795 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
02796                                uint8_t *scan_table)
02797 {
02798     int i, last_non_zero;
02799     const RLTable *rl;
02800     uint8_t *len_tab;
02801     const int last_index = s->block_last_index[n];
02802     int len=0;
02803 
02804     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
02805         /* mpeg4 based DC predictor */
02806         len += mpeg4_get_dc_length(intra_dc, n);
02807         if(last_index<1) return len;
02808         i = 1;
02809         rl = &rl_intra;
02810         len_tab = uni_mpeg4_intra_rl_len;
02811     } else {
02812         if(last_index<0) return 0;
02813         i = 0;
02814         rl = &rl_inter;
02815         len_tab = uni_mpeg4_inter_rl_len;
02816     }
02817 
02818     /* AC coefs */
02819     last_non_zero = i - 1;
02820     for (; i < last_index; i++) {
02821         int level = block[ scan_table[i] ];
02822         if (level) {
02823             int run = i - last_non_zero - 1;
02824             level+=64;
02825             if((level&(~127)) == 0){
02826                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
02827                 len += len_tab[index];
02828             }else{ //ESC3
02829                 len += 7+2+1+6+1+12+1;
02830             }
02831             last_non_zero = i;
02832         }
02833     }
02834     /*if(i<=last_index)*/{
02835         int level = block[ scan_table[i] ];
02836         int run = i - last_non_zero - 1;
02837         level+=64;
02838         if((level&(~127)) == 0){
02839             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
02840             len += len_tab[index];
02841         }else{ //ESC3
02842             len += 7+2+1+6+1+12+1;
02843         }
02844     }
02845     
02846     return len;
02847 }
02848 
02849 #endif
02850 
02851 
02852 /***********************************************/
02853 /* decoding */
02854 
02855 static VLC intra_MCBPC_vlc;
02856 static VLC inter_MCBPC_vlc;
02857 static VLC cbpy_vlc;
02858 static VLC mv_vlc;
02859 static VLC dc_lum, dc_chrom;
02860 static VLC sprite_trajectory;
02861 static VLC mb_type_b_vlc;
02862 static VLC h263_mbtype_b_vlc;
02863 static VLC cbpc_b_vlc;
02864 
02865 void init_vlc_rl(RLTable *rl, int use_static)
02866 {
02867     int i, q;
02868  
02869     /* Return if static table is already initialized */
02870     if(use_static && rl->rl_vlc[0])
02871         return;    
02872 
02873     init_vlc(&rl->vlc, 9, rl->n + 1, 
02874              &rl->table_vlc[0][1], 4, 2,
02875              &rl->table_vlc[0][0], 4, 2, use_static);
02876 
02877     
02878     for(q=0; q<32; q++){
02879         int qmul= q*2;
02880         int qadd= (q-1)|1;
02881         
02882         if(q==0){
02883             qmul=1;
02884             qadd=0;
02885         }
02886         if(use_static)        
02887             rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
02888         else
02889             rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
02890         for(i=0; i<rl->vlc.table_size; i++){
02891             int code= rl->vlc.table[i][0];
02892             int len = rl->vlc.table[i][1];
02893             int level, run;
02894         
02895             if(len==0){ // illegal code
02896                 run= 66;
02897                 level= MAX_LEVEL;
02898             }else if(len<0){ //more bits needed
02899                 run= 0;
02900                 level= code;
02901             }else{
02902                 if(code==rl->n){ //esc
02903                     run= 66;
02904                     level= 0;
02905                 }else{
02906                     run=   rl->table_run  [code] + 1;
02907                     level= rl->table_level[code] * qmul + qadd;
02908                     if(code >= rl->last) run+=192;
02909                 }
02910             }
02911             rl->rl_vlc[q][i].len= len;
02912             rl->rl_vlc[q][i].level= level;
02913             rl->rl_vlc[q][i].run= run;
02914         }
02915     }
02916 }
02917 
02918 /* init vlcs */
02919 
02920 /* XXX: find a better solution to handle static init */
02921 void h263_decode_init_vlc(MpegEncContext *s)
02922 {
02923     static int done = 0;
02924 
02925     if (!done) {
02926         done = 1;
02927 
02928         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
02929                  intra_MCBPC_bits, 1, 1,
02930                  intra_MCBPC_code, 1, 1, 1);
02931         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
02932                  inter_MCBPC_bits, 1, 1,
02933                  inter_MCBPC_code, 1, 1, 1);
02934         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
02935                  &cbpy_tab[0][1], 2, 1,
02936                  &cbpy_tab[0][0], 2, 1, 1);
02937         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
02938                  &mvtab[0][1], 2, 1,
02939                  &mvtab[0][0], 2, 1, 1);
02940         init_rl(&rl_inter, 1);
02941         init_rl(&rl_intra, 1);
02942         init_rl(&rvlc_rl_inter, 1);
02943         init_rl(&rvlc_rl_intra, 1);
02944         init_rl(&rl_intra_aic, 1);
02945         init_vlc_rl(&rl_inter, 1);
02946         init_vlc_rl(&rl_intra, 1);
02947         init_vlc_rl(&rvlc_rl_inter, 1);
02948         init_vlc_rl(&rvlc_rl_intra, 1);
02949         init_vlc_rl(&rl_intra_aic, 1);
02950         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
02951                  &DCtab_lum[0][1], 2, 1,
02952                  &DCtab_lum[0][0], 2, 1, 1);
02953         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
02954                  &DCtab_chrom[0][1], 2, 1,
02955                  &DCtab_chrom[0][0], 2, 1, 1);
02956         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
02957                  &sprite_trajectory_tab[0][1], 4, 2,
02958                  &sprite_trajectory_tab[0][0], 4, 2, 1);
02959         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
02960                  &mb_type_b_tab[0][1], 2, 1,
02961                  &mb_type_b_tab[0][0], 2, 1, 1);
02962         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
02963                  &h263_mbtype_b_tab[0][1], 2, 1,
02964                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
02965         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
02966                  &cbpc_b_tab[0][1], 2, 1,
02967                  &cbpc_b_tab[0][0], 2, 1, 1);
02968     }
02969 }
02970 
02974 int ff_h263_get_gob_height(MpegEncContext *s){
02975     if (s->height <= 400)
02976         return 1;
02977     else if (s->height <= 800)
02978         return  2;
02979     else
02980         return 4;
02981 }
02982 
02983 int ff_h263_decode_mba(MpegEncContext *s)
02984 {
02985     int i, mb_pos;
02986 
02987     for(i=0; i<6; i++){
02988         if(s->mb_num-1 <= ff_mba_max[i]) break;
02989     }
02990     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
02991     s->mb_x= mb_pos % s->mb_width;
02992     s->mb_y= mb_pos / s->mb_width;
02993 
02994     return mb_pos;
02995 }
02996 
02997 void ff_h263_encode_mba(MpegEncContext *s)
02998 {
02999     int i, mb_pos;
03000 
03001     for(i=0; i<6; i++){
03002         if(s->mb_num-1 <= ff_mba_max[i]) break;
03003     }
03004     mb_pos= s->mb_x + s->mb_width*s->mb_y;
03005     put_bits(&s->pb, ff_mba_length[i], mb_pos);
03006 }
03007 
03012 static int h263_decode_gob_header(MpegEncContext *s)
03013 {
03014     unsigned int val, gfid, gob_number;
03015     int left;
03016     
03017     /* Check for GOB Start Code */
03018     val = show_bits(&s->gb, 16);
03019     if(val)
03020         return -1;
03021 
03022         /* We have a GBSC probably with GSTUFF */
03023     skip_bits(&s->gb, 16); /* Drop the zeros */
03024     left= s->gb.size_in_bits - get_bits_count(&s->gb);
03025     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
03026     for(;left>13; left--){
03027         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
03028     }
03029     if(left<=13) 
03030         return -1;
03031 
03032     if(s->h263_slice_structured){
03033         if(get_bits1(&s->gb)==0)
03034             return -1;
03035 
03036         ff_h263_decode_mba(s);
03037 
03038         if(s->mb_num > 1583)
03039             if(get_bits1(&s->gb)==0)
03040                 return -1;
03041         
03042         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
03043         if(get_bits1(&s->gb)==0)
03044             return -1;
03045         gfid = get_bits(&s->gb, 2); /* GFID */
03046     }else{
03047         gob_number = get_bits(&s->gb, 5); /* GN */
03048         s->mb_x= 0;
03049         s->mb_y= s->gob_index* gob_number;
03050         gfid = get_bits(&s->gb, 2); /* GFID */
03051         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
03052     }
03053         
03054     if(s->mb_y >= s->mb_height) 
03055         return -1;
03056 
03057     if(s->qscale==0) 
03058         return -1;
03059 
03060     return 0;
03061 }
03062 
03063 static inline void memsetw(short *tab, int val, int n)
03064 {
03065     int i;
03066     for(i=0;i<n;i++)
03067         tab[i] = val;
03068 }
03069 
03070 #ifdef CONFIG_ENCODERS
03071 
03072 void ff_mpeg4_init_partitions(MpegEncContext *s)
03073 {
03074     uint8_t *start= pbBufPtr(&s->pb);
03075     uint8_t *end= s->pb.buf_end;
03076     int size= end - start;
03077     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
03078     int tex_size= (size - 2*pb_size)&(~3);
03079     
03080     set_put_bits_buffer_size(&s->pb, pb_size);
03081     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
03082     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
03083 }
03084 
03085 void ff_mpeg4_merge_partitions(MpegEncContext *s)
03086 {
03087     const int pb2_len   = put_bits_count(&s->pb2   );
03088     const int tex_pb_len= put_bits_count(&s->tex_pb);
03089     const int bits= put_bits_count(&s->pb);
03090 
03091     if(s->pict_type==I_TYPE){
03092         put_bits(&s->pb, 19, DC_MARKER);
03093         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
03094         s->i_tex_bits+= tex_pb_len;
03095     }else{
03096         put_bits(&s->pb, 17, MOTION_MARKER);
03097         s->misc_bits+=17 + pb2_len;
03098         s->mv_bits+= bits - s->last_bits;
03099         s->p_tex_bits+= tex_pb_len;
03100     }
03101 
03102     flush_put_bits(&s->pb2);
03103     flush_put_bits(&s->tex_pb);
03104 
03105     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
03106     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
03107     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
03108     s->last_bits= put_bits_count(&s->pb);
03109 }
03110 
03111 #endif //CONFIG_ENCODERS
03112 
03113 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
03114     switch(s->pict_type){
03115         case I_TYPE:
03116             return 16;
03117         case P_TYPE:
03118         case S_TYPE:
03119             return s->f_code+15;
03120         case B_TYPE:
03121             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
03122         default:
03123             return -1;
03124     }
03125 }
03126 
03127 #ifdef CONFIG_ENCODERS
03128 
03129 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
03130 {
03131     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
03132 
03133     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
03134     put_bits(&s->pb, 1, 1);
03135     
03136     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
03137     put_bits(&s->pb, s->quant_precision, s->qscale);
03138     put_bits(&s->pb, 1, 0); /* no HEC */
03139 }
03140 
03141 #endif //CONFIG_ENCODERS
03142 
03147 static inline int mpeg4_is_resync(MpegEncContext *s){
03148     const int bits_count= get_bits_count(&s->gb);
03149     
03150     if(s->workaround_bugs&FF_BUG_NO_PADDING){
03151         return 0;
03152     }
03153 
03154     if(bits_count + 8 >= s->gb.size_in_bits){
03155         int v= show_bits(&s->gb, 8);
03156         v|= 0x7F >> (7-(bits_count&7));
03157                 
03158         if(v==0x7F)
03159             return 1;
03160     }else{
03161         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
03162             int len;
03163             GetBitContext gb= s->gb;
03164         
03165             skip_bits(&s->gb, 1);
03166             align_get_bits(&s->gb);
03167         
03168             for(len=0; len<32; len++){
03169                 if(get_bits1(&s->gb)) break;
03170             }
03171 
03172             s->gb= gb;
03173 
03174             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
03175                 return 1;
03176         }
03177     }
03178     return 0;
03179 }
03180 
03185 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
03186 {
03187     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
03188     int header_extension=0, mb_num, len;
03189     
03190     /* is there enough space left for a video packet + header */
03191     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
03192 
03193     for(len=0; len<32; len++){
03194         if(get_bits1(&s->gb)) break;
03195     }
03196 
03197     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
03198         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
03199         return -1;
03200     }
03201     
03202     if(s->shape != RECT_SHAPE){
03203         header_extension= get_bits1(&s->gb);
03204         //FIXME more stuff here
03205     }
03206 
03207     mb_num= get_bits(&s->gb, mb_num_bits);
03208     if(mb_num>=s->mb_num){
03209         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
03210         return -1;
03211     }
03212     if(s->pict_type == B_TYPE){
03213         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
03214         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
03215     }
03216     
03217     s->mb_x= mb_num % s->mb_width;
03218     s->mb_y= mb_num / s->mb_width;
03219 
03220     if(s->shape != BIN_ONLY_SHAPE){
03221         int qscale= get_bits(&s->gb, s->quant_precision); 
03222         if(qscale)
03223             s->chroma_qscale=s->qscale= qscale;
03224     }
03225 
03226     if(s->shape == RECT_SHAPE){
03227         header_extension= get_bits1(&s->gb);
03228     }
03229     if(header_extension){
03230         int time_increment;
03231         int time_incr=0;
03232 
03233         while (get_bits1(&s->gb) != 0) 
03234             time_incr++;
03235 
03236         check_marker(&s->gb, "before time_increment in video packed header");
03237         time_increment= get_bits(&s->gb, s->time_increment_bits);
03238         check_marker(&s->gb, "before vop_coding_type in video packed header");
03239         
03240         skip_bits(&s->gb, 2); /* vop coding type */
03241         //FIXME not rect stuff here
03242 
03243         if(s->shape != BIN_ONLY_SHAPE){
03244             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
03245 //FIXME don't just ignore everything
03246             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03247                 mpeg4_decode_sprite_trajectory(s, &s->gb);
03248                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
03249             }
03250 
03251             //FIXME reduced res stuff here
03252             
03253             if (s->pict_type != I_TYPE) {
03254                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
03255                 if(f_code==0){
03256                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
03257                 }
03258             }
03259             if (s->pict_type == B_TYPE) {
03260                 int b_code = get_bits(&s->gb, 3);
03261                 if(b_code==0){
03262                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
03263                 }
03264             }       
03265         }
03266     }
03267     //FIXME new-pred stuff
03268     
03269 //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));
03270 
03271     return 0;
03272 }
03273 
03274 void ff_mpeg4_clean_buffers(MpegEncContext *s)
03275 {
03276     int c_wrap, c_xy, l_wrap, l_xy;
03277 
03278     l_wrap= s->b8_stride;
03279     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
03280     c_wrap= s->mb_stride;
03281     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
03282 
03283 #if 0
03284     /* clean DC */
03285     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
03286     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
03287     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
03288 #endif
03289 
03290     /* clean AC */
03291     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
03292     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
03293     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
03294 
03295     /* clean MV */
03296     // we can't clear the MVs as they might be needed by a b frame
03297 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
03298 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
03299     s->last_mv[0][0][0]=
03300     s->last_mv[0][0][1]=
03301     s->last_mv[1][0][0]=
03302     s->last_mv[1][0][1]= 0;
03303 }
03304 
03309 int ff_h263_resync(MpegEncContext *s){
03310     int left, ret;
03311     
03312     if(s->codec_id==CODEC_ID_MPEG4){
03313         skip_bits1(&s->gb);
03314         align_get_bits(&s->gb);
03315     }
03316 
03317     if(show_bits(&s->gb, 16)==0){
03318         if(s->codec_id==CODEC_ID_MPEG4)
03319             ret= mpeg4_decode_video_packet_header(s);
03320         else
03321             ret= h263_decode_gob_header(s);
03322         if(ret>=0)
03323             return 0;
03324     }
03325     //ok, it's not where its supposed to be ...
03326     s->gb= s->last_resync_gb;
03327     align_get_bits(&s->gb);
03328     left= s->gb.size_in_bits - get_bits_count(&s->gb);
03329     
03330     for(;left>16+1+5+5; left-=8){ 
03331         if(show_bits(&s->gb, 16)==0){
03332             GetBitContext bak= s->gb;
03333 
03334             if(s->codec_id==CODEC_ID_MPEG4)
03335                 ret= mpeg4_decode_video_packet_header(s);
03336             else
03337                 ret= h263_decode_gob_header(s);
03338             if(ret>=0)
03339                 return 0;
03340 
03341             s->gb= bak;
03342         }
03343         skip_bits(&s->gb, 8);
03344     }
03345     
03346     return -1;
03347 }
03348 
03354 static inline int get_amv(MpegEncContext *s, int n){
03355     int x, y, mb_v, sum, dx, dy, shift;
03356     int len = 1 << (s->f_code + 4);
03357     const int a= s->sprite_warping_accuracy;
03358     
03359     if(s->workaround_bugs & FF_BUG_AMV)
03360         len >>= s->quarter_sample;
03361 
03362     if(s->real_sprite_warping_points==1){
03363         if(s->divx_version==500 && s->divx_build==413)
03364             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
03365         else
03366             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
03367     }else{
03368         dx= s->sprite_delta[n][0];
03369         dy= s->sprite_delta[n][1];
03370         shift= s->sprite_shift[0];
03371         if(n) dy -= 1<<(shift + a + 1);
03372         else  dx -= 1<<(shift + a + 1);
03373         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
03374 
03375         sum=0;
03376         for(y=0; y<16; y++){
03377             int v;
03378         
03379             v= mb_v + dy*y;
03380             //XXX FIXME optimize
03381             for(x=0; x<16; x++){
03382                 sum+= v>>shift;
03383                 v+= dx;
03384             }
03385         }
03386         sum= RSHIFT(sum, a+8-s->quarter_sample);
03387     }
03388 
03389     if      (sum < -len) sum= -len;
03390     else if (sum >= len) sum= len-1;
03391 
03392     return sum;
03393 }
03394 
03399 static int mpeg4_decode_partition_a(MpegEncContext *s){
03400     int mb_num;
03401     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03402     
03403     /* decode first partition */
03404     mb_num=0;
03405     s->first_slice_line=1;
03406     for(; s->mb_y<s->mb_height; s->mb_y++){
03407         ff_init_block_index(s);
03408         for(; s->mb_x<s->mb_width; s->mb_x++){
03409             const int xy= s->mb_x + s->mb_y*s->mb_stride;
03410             int cbpc;
03411             int dir=0;
03412             
03413             mb_num++;
03414             ff_update_block_index(s);
03415             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
03416                 s->first_slice_line=0;
03417             
03418             if(s->pict_type==I_TYPE){
03419                 int i;
03420 
03421                 do{
03422                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
03423                         return mb_num-1;
03424                     }
03425 
03426                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
03427                     if (cbpc < 0){
03428                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
03429                         return -1;
03430                     }
03431                 }while(cbpc == 8);
03432                 
03433                 s->cbp_table[xy]= cbpc & 3;
03434                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03435                 s->mb_intra = 1;
03436 
03437                 if(cbpc & 4) {
03438                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03439                 }
03440                 s->current_picture.qscale_table[xy]= s->qscale;
03441 
03442                 s->mbintra_table[xy]= 1;
03443                 for(i=0; i<6; i++){
03444                     int dc_pred_dir;
03445                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
03446                     if(dc < 0){
03447                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
03448                         return -1;
03449                     }
03450                     dir<<=1;
03451                     if(dc_pred_dir) dir|=1;
03452                 }
03453                 s->pred_dir_table[xy]= dir;
03454             }else{ /* P/S_TYPE */
03455                 int mx, my, pred_x, pred_y, bits;
03456                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
03457                 const int stride= s->b8_stride*2;
03458 
03459 try_again:
03460                 bits= show_bits(&s->gb, 17);
03461                 if(bits==MOTION_MARKER){
03462                     return mb_num-1;
03463                 }
03464                 skip_bits1(&s->gb);
03465                 if(bits&0x10000){
03466                     /* skip mb */
03467                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03468                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
03469                         mx= get_amv(s, 0);
03470                         my= get_amv(s, 1);
03471                     }else{
03472                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03473                         mx=my=0;
03474                     }
03475                     mot_val[0       ]= mot_val[2       ]=
03476                     mot_val[0+stride]= mot_val[2+stride]= mx;
03477                     mot_val[1       ]= mot_val[3       ]=
03478                     mot_val[1+stride]= mot_val[3+stride]= my;
03479 
03480                     if(s->mbintra_table[xy])
03481                         ff_clean_intra_table_entries(s);
03482                     continue;
03483                 }
03484 
03485                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03486                 if (cbpc < 0){
03487                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
03488                     return -1;
03489                 }
03490                 if(cbpc == 20)
03491                     goto try_again;
03492 
03493                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
03494     
03495                 s->