MythTV: h263.c Source File

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