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

libavcodec/mpeg4videoenc.c

Go to the documentation of this file.
00001 /*
00002  * MPEG4 encoder.
00003  * Copyright (c) 2000,2001 Fabrice Bellard
00004  * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
00005  *
00006  * This file is part of FFmpeg.
00007  *
00008  * FFmpeg is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * FFmpeg is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with FFmpeg; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00023 #include "mpegvideo.h"
00024 #include "h263.h"
00025 #include "mpeg4video.h"
00026 
00027 //The uni_DCtab_* tables below contain unified bits+length tables to encode DC
00028 //differences in mpeg4. Unified in the sense that the specification specifies
00029 //this encoding in several steps.
00030 static uint8_t uni_DCtab_lum_len[512];
00031 static uint8_t uni_DCtab_chrom_len[512];
00032 static uint16_t uni_DCtab_lum_bits[512];
00033 static uint16_t uni_DCtab_chrom_bits[512];
00034 
00035 //unified encoding tables for run length encoding of coefficients
00036 //unified in the sense that the specification specifies the encoding in several steps.
00037 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
00038 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
00039 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
00040 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
00041 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
00042 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
00043 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
00044 
00045 /* mpeg4
00046 inter
00047 max level: 24/6
00048 max run: 53/63
00049 
00050 intra
00051 max level: 53/16
00052 max run: 29/41
00053 */
00054 
00055 
00060 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
00061     int last=0;
00062     int j;
00063     int rate=0;
00064 
00065     for(j=1; j<=block_last_index; j++){
00066         const int index= scantable[j];
00067         int level= block[index];
00068         if(level){
00069             level+= 64;
00070             if((level&(~127)) == 0){
00071                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
00072                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
00073             }else
00074                 rate += s->ac_esc_length;
00075 
00076             last= j;
00077         }
00078     }
00079 
00080     return rate;
00081 }
00082 
00083 
00092 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], const int zigzag_last_index[6])
00093 {
00094     int i, n;
00095     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
00096 
00097     for(n=0; n<6; n++){
00098         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00099 
00100         st[n]= s->intra_scantable.permutated;
00101         if(dir[n]){
00102             /* top prediction */
00103             for(i=1; i<8; i++){
00104                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
00105             }
00106         }else{
00107             /* left prediction */
00108             for(i=1; i<8; i++){
00109                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
00110             }
00111         }
00112     }
00113 }
00114 
00123 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00124 {
00125     int score= 0;
00126     int i, n;
00127     int8_t * const qscale_table= s->current_picture.qscale_table;
00128 
00129     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
00130 
00131     for(n=0; n<6; n++){
00132         int16_t *ac_val, *ac_val1;
00133 
00134         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
00135 
00136         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00137         ac_val1= ac_val;
00138         if(dir[n]){
00139             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00140             /* top prediction */
00141             ac_val-= s->block_wrap[n]*16;
00142             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00143                 /* same qscale */
00144                 for(i=1; i<8; i++){
00145                     const int level= block[n][s->dsp.idct_permutation[i   ]];
00146                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
00147                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
00148                     ac_val1[i+8]= level;
00149                 }
00150             }else{
00151                 /* different qscale, we must rescale */
00152                 for(i=1; i<8; i++){
00153                     const int level= block[n][s->dsp.idct_permutation[i   ]];
00154                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00155                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
00156                     ac_val1[i+8]= level;
00157                 }
00158             }
00159             st[n]= s->intra_h_scantable.permutated;
00160         }else{
00161             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00162             /* left prediction */
00163             ac_val-= 16;
00164             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00165                 /* same qscale */
00166                 for(i=1; i<8; i++){
00167                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
00168                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
00169                     ac_val1[i  ]= level;
00170                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
00171                 }
00172             }else{
00173                 /* different qscale, we must rescale */
00174                 for(i=1; i<8; i++){
00175                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
00176                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00177                     ac_val1[i  ]= level;
00178                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
00179                 }
00180             }
00181             st[n]= s->intra_v_scantable.permutated;
00182         }
00183 
00184         for(i=63; i>0; i--) //FIXME optimize
00185             if(block[n][ st[n][i] ]) break;
00186         s->block_last_index[n]= i;
00187 
00188         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
00189     }
00190 
00191     if(score < 0){
00192         return 1;
00193     }else{
00194         restore_ac_coeffs(s, block, dir, st, zigzag_last_index);
00195         return 0;
00196     }
00197 }
00198 
00202 void ff_clean_mpeg4_qscales(MpegEncContext *s){
00203     int i;
00204     int8_t * const qscale_table= s->current_picture.qscale_table;
00205 
00206     ff_clean_h263_qscales(s);
00207 
00208     if(s->pict_type== FF_B_TYPE){
00209         int odd=0;
00210         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
00211 
00212         for(i=0; i<s->mb_num; i++){
00213             int mb_xy= s->mb_index2xy[i];
00214             odd += qscale_table[mb_xy]&1;
00215         }
00216 
00217         if(2*odd > s->mb_num) odd=1;
00218         else                  odd=0;
00219 
00220         for(i=0; i<s->mb_num; i++){
00221             int mb_xy= s->mb_index2xy[i];
00222             if((qscale_table[mb_xy]&1) != odd)
00223                 qscale_table[mb_xy]++;
00224             if(qscale_table[mb_xy] > 31)
00225                 qscale_table[mb_xy]= 31;
00226         }
00227 
00228         for(i=1; i<s->mb_num; i++){
00229             int mb_xy= s->mb_index2xy[i];
00230             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
00231                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
00232             }
00233         }
00234     }
00235 }
00236 
00237 
00242 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
00243 {
00244 #if 1
00245     /* DC will overflow if level is outside the [-255,255] range. */
00246     level+=256;
00247     if (n < 4) {
00248         /* luminance */
00249         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
00250     } else {
00251         /* chrominance */
00252         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
00253     }
00254 #else
00255     int size, v;
00256     /* find number of bits */
00257     size = 0;
00258     v = abs(level);
00259     while (v) {
00260         v >>= 1;
00261         size++;
00262     }
00263 
00264     if (n < 4) {
00265         /* luminance */
00266         put_bits(&s->pb, ff_mpeg4_DCtab_lum[size][1], ff_mpeg4_DCtab_lum[size][0]);
00267     } else {
00268         /* chrominance */
00269         put_bits(&s->pb, ff_mpeg4_DCtab_chrom[size][1], ff_mpeg4_DCtab_chrom[size][0]);
00270     }
00271 
00272     /* encode remaining bits */
00273     if (size > 0) {
00274         if (level < 0)
00275             level = (-level) ^ ((1 << size) - 1);
00276         put_bits(&s->pb, size, level);
00277         if (size > 8)
00278             put_bits(&s->pb, 1, 1);
00279     }
00280 #endif
00281 }
00282 
00283 static inline int mpeg4_get_dc_length(int level, int n){
00284     if (n < 4) {
00285         return uni_DCtab_lum_len[level + 256];
00286     } else {
00287         return uni_DCtab_chrom_len[level + 256];
00288     }
00289 }
00290 
00295 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
00296                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
00297 {
00298     int i, last_non_zero;
00299 #if 0 //variables for the outcommented version
00300     int code, sign, last;
00301 #endif
00302     const RLTable *rl;
00303     uint32_t *bits_tab;
00304     uint8_t *len_tab;
00305     const int last_index = s->block_last_index[n];
00306 
00307     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
00308         /* mpeg4 based DC predictor */
00309         mpeg4_encode_dc(dc_pb, intra_dc, n);
00310         if(last_index<1) return;
00311         i = 1;
00312         rl = &ff_mpeg4_rl_intra;
00313         bits_tab= uni_mpeg4_intra_rl_bits;
00314         len_tab = uni_mpeg4_intra_rl_len;
00315     } else {
00316         if(last_index<0) return;
00317         i = 0;
00318         rl = &ff_h263_rl_inter;
00319         bits_tab= uni_mpeg4_inter_rl_bits;
00320         len_tab = uni_mpeg4_inter_rl_len;
00321     }
00322 
00323     /* AC coefs */
00324     last_non_zero = i - 1;
00325 #if 1
00326     for (; i < last_index; i++) {
00327         int level = block[ scan_table[i] ];
00328         if (level) {
00329             int run = i - last_non_zero - 1;
00330             level+=64;
00331             if((level&(~127)) == 0){
00332                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
00333                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
00334             }else{ //ESC3
00335                 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);
00336             }
00337             last_non_zero = i;
00338         }
00339     }
00340     /*if(i<=last_index)*/{
00341         int level = block[ scan_table[i] ];
00342         int run = i - last_non_zero - 1;
00343         level+=64;
00344         if((level&(~127)) == 0){
00345             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
00346             put_bits(ac_pb, len_tab[index], bits_tab[index]);
00347         }else{ //ESC3
00348             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);
00349         }
00350     }
00351 #else
00352     for (; i <= last_index; i++) {
00353         const int slevel = block[ scan_table[i] ];
00354         if (slevel) {
00355             int level;
00356             int run = i - last_non_zero - 1;
00357             last = (i == last_index);
00358             sign = 0;
00359             level = slevel;
00360             if (level < 0) {
00361                 sign = 1;
00362                 level = -level;
00363             }
00364             code = get_rl_index(rl, last, run, level);
00365             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00366             if (code == rl->n) {
00367                 int level1, run1;
00368                 level1 = level - rl->max_level[last][run];
00369                 if (level1 < 1)
00370                     goto esc2;
00371                 code = get_rl_index(rl, last, run, level1);
00372                 if (code == rl->n) {
00373                 esc2:
00374                     put_bits(ac_pb, 1, 1);
00375                     if (level > MAX_LEVEL)
00376                         goto esc3;
00377                     run1 = run - rl->max_run[last][level] - 1;
00378                     if (run1 < 0)
00379                         goto esc3;
00380                     code = get_rl_index(rl, last, run1, level);
00381                     if (code == rl->n) {
00382                     esc3:
00383                         /* third escape */
00384                         put_bits(ac_pb, 1, 1);
00385                         put_bits(ac_pb, 1, last);
00386                         put_bits(ac_pb, 6, run);
00387                         put_bits(ac_pb, 1, 1);
00388                         put_sbits(ac_pb, 12, slevel);
00389                         put_bits(ac_pb, 1, 1);
00390                     } else {
00391                         /* second escape */
00392                         put_bits(ac_pb, 1, 0);
00393                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00394                         put_bits(ac_pb, 1, sign);
00395                     }
00396                 } else {
00397                     /* first escape */
00398                     put_bits(ac_pb, 1, 0);
00399                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00400                     put_bits(ac_pb, 1, sign);
00401                 }
00402             } else {
00403                 put_bits(ac_pb, 1, sign);
00404             }
00405             last_non_zero = i;
00406         }
00407     }
00408 #endif
00409 }
00410 
00411 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
00412                                uint8_t *scan_table)
00413 {
00414     int i, last_non_zero;
00415     uint8_t *len_tab;
00416     const int last_index = s->block_last_index[n];
00417     int len=0;
00418 
00419     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
00420         /* mpeg4 based DC predictor */
00421         len += mpeg4_get_dc_length(intra_dc, n);
00422         if(last_index<1) return len;
00423         i = 1;
00424         len_tab = uni_mpeg4_intra_rl_len;
00425     } else {
00426         if(last_index<0) return 0;
00427         i = 0;
00428         len_tab = uni_mpeg4_inter_rl_len;
00429     }
00430 
00431     /* AC coefs */
00432     last_non_zero = i - 1;
00433     for (; i < last_index; i++) {
00434         int level = block[ scan_table[i] ];
00435         if (level) {
00436             int run = i - last_non_zero - 1;
00437             level+=64;
00438             if((level&(~127)) == 0){
00439                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
00440                 len += len_tab[index];
00441             }else{ //ESC3
00442                 len += 7+2+1+6+1+12+1;
00443             }
00444             last_non_zero = i;
00445         }
00446     }
00447     /*if(i<=last_index)*/{
00448         int level = block[ scan_table[i] ];
00449         int run = i - last_non_zero - 1;
00450         level+=64;
00451         if((level&(~127)) == 0){
00452             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
00453             len += len_tab[index];
00454         }else{ //ESC3
00455             len += 7+2+1+6+1+12+1;
00456         }
00457     }
00458 
00459     return len;
00460 }
00461 
00462 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
00463                                uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
00464     int i;
00465 
00466     if(scan_table){
00467         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00468             for (i = 0; i < 6; i++) {
00469                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
00470             }
00471         }else{
00472             /* encode each block */
00473             for (i = 0; i < 6; i++) {
00474                 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
00475             }
00476         }
00477     }else{
00478         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00479             for (i = 0; i < 6; i++) {
00480                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
00481             }
00482         }else{
00483             /* encode each block */
00484             for (i = 0; i < 6; i++) {
00485                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
00486             }
00487         }
00488     }
00489 }
00490 
00491 //FIXME this is duplicated to h263.c
00492 static const int dquant_code[5]= {1,0,9,2,3};
00493 
00494 void mpeg4_encode_mb(MpegEncContext * s,
00495                     DCTELEM block[6][64],
00496                     int motion_x, int motion_y)
00497 {
00498     int cbpc, cbpy, pred_x, pred_y;
00499     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
00500     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb;
00501     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2    : &s->pb;
00502     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
00503 
00504     if (!s->mb_intra) {
00505         int i, cbp;
00506 
00507         if(s->pict_type==FF_B_TYPE){
00508             static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
00509             int mb_type=  mb_type_table[s->mv_dir];
00510 
00511             if(s->mb_x==0){
00512                 for(i=0; i<2; i++){
00513                     s->last_mv[i][0][0]=
00514                     s->last_mv[i][0][1]=
00515                     s->last_mv[i][1][0]=
00516                     s->last_mv[i][1][1]= 0;
00517                 }
00518             }
00519 
00520             assert(s->dquant>=-2 && s->dquant<=2);
00521             assert((s->dquant&1)==0);
00522             assert(mb_type>=0);
00523 
00524             /* nothing to do if this MB was skipped in the next P Frame */
00525             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
00526                 s->skip_count++;
00527                 s->mv[0][0][0]=
00528                 s->mv[0][0][1]=
00529                 s->mv[1][0][0]=
00530                 s->mv[1][0][1]= 0;
00531                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
00532                 s->qscale -= s->dquant;
00533 //                s->mb_skipped=1;
00534 
00535                 return;
00536             }
00537 
00538             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
00539 
00540             if ((cbp | motion_x | motion_y | mb_type) ==0) {
00541                 /* direct MB with MV={0,0} */
00542                 assert(s->dquant==0);
00543 
00544                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
00545 
00546                 if(interleaved_stats){
00547                     s->misc_bits++;
00548                     s->last_bits++;
00549                 }
00550                 s->skip_count++;
00551                 return;
00552             }
00553 
00554             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
00555             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
00556             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
00557             if(cbp) put_bits(&s->pb, 6, cbp);
00558 
00559             if(cbp && mb_type){
00560                 if(s->dquant)
00561                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
00562                 else
00563                     put_bits(&s->pb, 1, 0);
00564             }else
00565                 s->qscale -= s->dquant;
00566 
00567             if(!s->progressive_sequence){
00568                 if(cbp)
00569                     put_bits(&s->pb, 1, s->interlaced_dct);
00570                 if(mb_type) // not direct mode
00571                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
00572             }
00573 
00574             if(interleaved_stats){
00575                 s->misc_bits+= get_bits_diff(s);
00576             }
00577 
00578             if(mb_type == 0){
00579                 assert(s->mv_dir & MV_DIRECT);
00580                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
00581                 s->b_count++;
00582                 s->f_count++;
00583             }else{
00584                 assert(mb_type > 0 && mb_type < 4);
00585                 if(s->mv_type != MV_TYPE_FIELD){
00586                     if(s->mv_dir & MV_DIR_FORWARD){
00587                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
00588                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
00589                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
00590                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
00591                         s->f_count++;
00592                     }
00593                     if(s->mv_dir & MV_DIR_BACKWARD){
00594                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
00595                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
00596                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
00597                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
00598                         s->b_count++;
00599                     }
00600                 }else{
00601                     if(s->mv_dir & MV_DIR_FORWARD){
00602                         put_bits(&s->pb, 1, s->field_select[0][0]);
00603                         put_bits(&s->pb, 1, s->field_select[0][1]);
00604                     }
00605                     if(s->mv_dir & MV_DIR_BACKWARD){
00606                         put_bits(&s->pb, 1, s->field_select[1][0]);
00607                         put_bits(&s->pb, 1, s->field_select[1][1]);
00608                     }
00609                     if(s->mv_dir & MV_DIR_FORWARD){
00610                         for(i=0; i<2; i++){
00611                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
00612                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
00613                             s->last_mv[0][i][0]= s->mv[0][i][0];
00614                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
00615                         }
00616                         s->f_count++;
00617                     }
00618                     if(s->mv_dir & MV_DIR_BACKWARD){
00619                         for(i=0; i<2; i++){
00620                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
00621                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
00622                             s->last_mv[1][i][0]= s->mv[1][i][0];
00623                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
00624                         }
00625                         s->b_count++;
00626                     }
00627                 }
00628             }
00629 
00630             if(interleaved_stats){
00631                 s->mv_bits+= get_bits_diff(s);
00632             }
00633 
00634             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
00635 
00636             if(interleaved_stats){
00637                 s->p_tex_bits+= get_bits_diff(s);
00638             }
00639 
00640         }else{ /* s->pict_type==FF_B_TYPE */
00641             cbp= get_p_cbp(s, block, motion_x, motion_y);
00642 
00643             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
00644                 /* check if the B frames can skip it too, as we must skip it if we skip here
00645                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
00646                 if(s->max_b_frames>0){
00647                     int i;
00648                     int x,y, offset;
00649                     uint8_t *p_pic;
00650 
00651                     x= s->mb_x*16;
00652                     y= s->mb_y*16;
00653                     if(x+16 > s->width)  x= s->width-16;
00654                     if(y+16 > s->height) y= s->height-16;
00655 
00656                     offset= x + y*s->linesize;
00657                     p_pic= s->new_picture.data[0] + offset;
00658 
00659                     s->mb_skipped=1;
00660                     for(i=0; i<s->max_b_frames; i++){
00661                         uint8_t *b_pic;
00662                         int diff;
00663                         Picture *pic= s->reordered_input_picture[i+1];
00664 
00665                         if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
00666 
00667                         b_pic= pic->data[0] + offset;
00668                         if(pic->type != FF_BUFFER_TYPE_SHARED)
00669                             b_pic+= INPLACE_OFFSET;
00670                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
00671                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
00672                             s->mb_skipped=0;
00673                             break;
00674                         }
00675                     }
00676                 }else
00677                     s->mb_skipped=1;
00678 
00679                 if(s->mb_skipped==1){
00680                     /* skip macroblock */
00681                     put_bits(&s->pb, 1, 1);
00682 
00683                     if(interleaved_stats){
00684                         s->misc_bits++;
00685                         s->last_bits++;
00686                     }
00687                     s->skip_count++;
00688 
00689                     return;
00690                 }
00691             }
00692 
00693             put_bits(&s->pb, 1, 0);     /* mb coded */
00694             cbpc = cbp & 3;
00695             cbpy = cbp >> 2;
00696             cbpy ^= 0xf;
00697             if(s->mv_type==MV_TYPE_16X16){
00698                 if(s->dquant) cbpc+= 8;
00699                 put_bits(&s->pb,
00700                         ff_h263_inter_MCBPC_bits[cbpc],
00701                         ff_h263_inter_MCBPC_code[cbpc]);
00702 
00703                 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00704                 if(s->dquant)
00705                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
00706 
00707                 if(!s->progressive_sequence){
00708                     if(cbp)
00709                         put_bits(pb2, 1, s->interlaced_dct);
00710                     put_bits(pb2, 1, 0);
00711                 }
00712 
00713                 if(interleaved_stats){
00714                     s->misc_bits+= get_bits_diff(s);
00715                 }
00716 
00717                 /* motion vectors: 16x16 mode */
00718                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00719 
00720                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
00721                                                 motion_y - pred_y, s->f_code);
00722             }else if(s->mv_type==MV_TYPE_FIELD){
00723                 if(s->dquant) cbpc+= 8;
00724                 put_bits(&s->pb,
00725                         ff_h263_inter_MCBPC_bits[cbpc],
00726                         ff_h263_inter_MCBPC_code[cbpc]);
00727 
00728                 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00729                 if(s->dquant)
00730                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
00731 
00732                 assert(!s->progressive_sequence);
00733                 if(cbp)
00734                     put_bits(pb2, 1, s->interlaced_dct);
00735                 put_bits(pb2, 1, 1);
00736 
00737                 if(interleaved_stats){
00738                     s->misc_bits+= get_bits_diff(s);
00739                 }
00740 
00741                 /* motion vectors: 16x8 interlaced mode */
00742                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00743                 pred_y /=2;
00744 
00745                 put_bits(&s->pb, 1, s->field_select[0][0]);
00746                 put_bits(&s->pb, 1, s->field_select[0][1]);
00747 
00748                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
00749                                                 s->mv[0][0][1] - pred_y, s->f_code);
00750                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
00751                                                 s->mv[0][1][1] - pred_y, s->f_code);
00752             }else{
00753                 assert(s->mv_type==MV_TYPE_8X8);
00754                 put_bits(&s->pb,
00755                         ff_h263_inter_MCBPC_bits[cbpc+16],
00756                         ff_h263_inter_MCBPC_code[cbpc+16]);
00757                 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00758 
00759                 if(!s->progressive_sequence){
00760                     if(cbp)
00761                         put_bits(pb2, 1, s->interlaced_dct);
00762                 }
00763 
00764                 if(interleaved_stats){
00765                     s->misc_bits+= get_bits_diff(s);
00766                 }
00767 
00768                 for(i=0; i<4; i++){
00769                     /* motion vectors: 8x8 mode*/
00770                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
00771 
00772                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
00773                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
00774                 }
00775             }
00776 
00777             if(interleaved_stats){
00778                 s->mv_bits+= get_bits_diff(s);
00779             }
00780 
00781             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
00782 
00783             if(interleaved_stats){
00784                 s->p_tex_bits+= get_bits_diff(s);
00785             }
00786             s->f_count++;
00787         }
00788     } else {
00789         int cbp;
00790         int dc_diff[6];   //dc values with the dc prediction subtracted
00791         int dir[6];  //prediction direction
00792         int zigzag_last_index[6];
00793         uint8_t *scan_table[6];
00794         int i;
00795 
00796         for(i=0; i<6; i++){
00797             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
00798         }
00799 
00800         if(s->flags & CODEC_FLAG_AC_PRED){
00801             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
00802         }else{
00803             for(i=0; i<6; i++)
00804                 scan_table[i]= s->intra_scantable.permutated;
00805         }
00806 
00807         /* compute cbp */
00808         cbp = 0;
00809         for (i = 0; i < 6; i++) {
00810             if (s->block_last_index[i] >= 1)
00811                 cbp |= 1 << (5 - i);
00812         }
00813 
00814         cbpc = cbp & 3;
00815         if (s->pict_type == FF_I_TYPE) {
00816             if(s->dquant) cbpc+=4;
00817             put_bits(&s->pb,
00818                 ff_h263_intra_MCBPC_bits[cbpc],
00819                 ff_h263_intra_MCBPC_code[cbpc]);
00820         } else {
00821             if(s->dquant) cbpc+=8;
00822             put_bits(&s->pb, 1, 0);     /* mb coded */
00823             put_bits(&s->pb,
00824                 ff_h263_inter_MCBPC_bits[cbpc + 4],
00825                 ff_h263_inter_MCBPC_code[cbpc + 4]);
00826         }
00827         put_bits(pb2, 1, s->ac_pred);
00828         cbpy = cbp >> 2;
00829         put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00830         if(s->dquant)
00831             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
00832 
00833         if(!s->progressive_sequence){
00834             put_bits(dc_pb, 1, s->interlaced_dct);
00835         }
00836 
00837         if(interleaved_stats){
00838             s->misc_bits+= get_bits_diff(s);
00839         }
00840 
00841         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
00842 
00843         if(interleaved_stats){
00844             s->i_tex_bits+= get_bits_diff(s);
00845         }
00846         s->i_count++;
00847 
00848         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
00849         if(s->ac_pred)
00850             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
00851     }
00852 }
00853 
00857 void ff_mpeg4_stuffing(PutBitContext * pbc)
00858 {
00859     int length;
00860     put_bits(pbc, 1, 0);
00861     length= (-put_bits_count(pbc))&7;
00862     if(length) put_bits(pbc, length, (1<<length)-1);
00863 }
00864 
00865 /* must be called before writing the header */
00866 void ff_set_mpeg4_time(MpegEncContext * s){
00867     if(s->pict_type==FF_B_TYPE){
00868         ff_mpeg4_init_direct_mv(s);
00869     }else{
00870         s->last_time_base= s->time_base;
00871         s->time_base= s->time/s->avctx->time_base.den;
00872     }
00873 }
00874 
00875 static void mpeg4_encode_gop_header(MpegEncContext * s){
00876     int hours, minutes, seconds;
00877     int64_t time;
00878 
00879     put_bits(&s->pb, 16, 0);
00880     put_bits(&s->pb, 16, GOP_STARTCODE);
00881 
00882     time= s->current_picture_ptr->pts;
00883     if(s->reordered_input_picture[1])
00884         time= FFMIN(time, s->reordered_input_picture[1]->pts);
00885     time= time*s->avctx->time_base.num;
00886 
00887     seconds= time/s->avctx->time_base.den;
00888     minutes= seconds/60; seconds %= 60;
00889     hours= minutes/60; minutes %= 60;
00890     hours%=24;
00891 
00892     put_bits(&s->pb, 5, hours);
00893     put_bits(&s->pb, 6, minutes);
00894     put_bits(&s->pb, 1, 1);
00895     put_bits(&s->pb, 6, seconds);
00896 
00897     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
00898     put_bits(&s->pb, 1, 0); //broken link == NO
00899 
00900     s->last_time_base= time / s->avctx->time_base.den;
00901 
00902     ff_mpeg4_stuffing(&s->pb);
00903 }
00904 
00905 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
00906     int profile_and_level_indication;
00907     int vo_ver_id;
00908 
00909     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
00910         profile_and_level_indication = s->avctx->profile << 4;
00911     }else if(s->max_b_frames || s->quarter_sample){
00912         profile_and_level_indication= 0xF0; // adv simple
00913     }else{
00914         profile_and_level_indication= 0x00; // simple
00915     }
00916 
00917     if(s->avctx->level != FF_LEVEL_UNKNOWN){
00918         profile_and_level_indication |= s->avctx->level;
00919     }else{
00920         profile_and_level_indication |= 1; //level 1
00921     }
00922 
00923     if(profile_and_level_indication>>4 == 0xF){
00924         vo_ver_id= 5;
00925     }else{
00926         vo_ver_id= 1;
00927     }
00928 
00929     //FIXME levels
00930 
00931     put_bits(&s->pb, 16, 0);
00932     put_bits(&s->pb, 16, VOS_STARTCODE);
00933 
00934     put_bits(&s->pb, 8, profile_and_level_indication);
00935 
00936     put_bits(&s->pb, 16, 0);
00937     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
00938 
00939     put_bits(&s->pb, 1, 1);
00940         put_bits(&s->pb, 4, vo_ver_id);
00941         put_bits(&s->pb, 3, 1); //priority
00942 
00943     put_bits(&s->pb, 4, 1); //visual obj type== video obj
00944 
00945     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
00946 
00947     ff_mpeg4_stuffing(&s->pb);
00948 }
00949 
00950 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
00951 {
00952     int vo_ver_id;
00953 
00954     if (!CONFIG_MPEG4_ENCODER)  return;
00955 
00956     if(s->max_b_frames || s->quarter_sample){
00957         vo_ver_id= 5;
00958         s->vo_type= ADV_SIMPLE_VO_TYPE;
00959     }else{
00960         vo_ver_id= 1;
00961         s->vo_type= SIMPLE_VO_TYPE;
00962     }
00963 
00964     put_bits(&s->pb, 16, 0);
00965     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
00966     put_bits(&s->pb, 16, 0);
00967     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
00968 
00969     put_bits(&s->pb, 1, 0);             /* random access vol */
00970     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
00971     if(s->workaround_bugs & FF_BUG_MS) {
00972         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
00973     } else {
00974         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
00975         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
00976         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
00977     }
00978 
00979     s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
00980 
00981     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
00982     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
00983         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
00984         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
00985     }
00986 
00987     if(s->workaround_bugs & FF_BUG_MS) { //
00988         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
00989     } else {
00990         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
00991         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
00992         put_bits(&s->pb, 1, s->low_delay);
00993         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
00994     }
00995 
00996     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
00997     put_bits(&s->pb, 1, 1);             /* marker bit */
00998 
00999     put_bits(&s->pb, 16, s->avctx->time_base.den);
01000     if (s->time_increment_bits < 1)
01001         s->time_increment_bits = 1;
01002     put_bits(&s->pb, 1, 1);             /* marker bit */
01003     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
01004     put_bits(&s->pb, 1, 1);             /* marker bit */
01005     put_bits(&s->pb, 13, s->width);     /* vol width */
01006     put_bits(&s->pb, 1, 1);             /* marker bit */
01007     put_bits(&s->pb, 13, s->height);    /* vol height */
01008     put_bits(&s->pb, 1, 1);             /* marker bit */
01009     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
01010     put_bits(&s->pb, 1, 1);             /* obmc disable */
01011     if (vo_ver_id == 1) {
01012         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
01013     }else{
01014         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
01015     }
01016 
01017     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
01018     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
01019 
01020     if(s->mpeg_quant){
01021         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
01022         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
01023     }
01024 
01025     if (vo_ver_id != 1)
01026         put_bits(&s->pb, 1, s->quarter_sample);
01027     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
01028     s->resync_marker= s->rtp_mode;
01029     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
01030     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
01031     if(s->data_partitioning){
01032         put_bits(&s->pb, 1, 0);         /* no rvlc */
01033     }
01034 
01035     if (vo_ver_id != 1){
01036         put_bits(&s->pb, 1, 0);         /* newpred */
01037         put_bits(&s->pb, 1, 0);         /* reduced res vop */
01038     }
01039     put_bits(&s->pb, 1, 0);             /* scalability */
01040 
01041     ff_mpeg4_stuffing(&s->pb);
01042 
01043     /* user data */
01044     if(!(s->flags & CODEC_FLAG_BITEXACT)){
01045         put_bits(&s->pb, 16, 0);
01046         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
01047         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
01048     }
01049 }
01050 
01051 /* write mpeg4 VOP header */
01052 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
01053 {
01054     int time_incr;
01055     int time_div, time_mod;
01056 
01057     if(s->pict_type==FF_I_TYPE){
01058         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
01059             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
01060                 mpeg4_encode_visual_object_header(s);
01061             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
01062                 mpeg4_encode_vol_header(s, 0, 0);
01063         }
01064         if(!(s->workaround_bugs & FF_BUG_MS))
01065             mpeg4_encode_gop_header(s);
01066     }
01067 
01068     s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
01069 
01070     put_bits(&s->pb, 16, 0);                /* vop header */
01071     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
01072     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
01073 
01074     assert(s->time>=0);
01075     time_div= s->time/s->avctx->time_base.den;
01076     time_mod= s->time%s->avctx->time_base.den;
01077     time_incr= time_div - s->last_time_base;
01078     assert(time_incr >= 0);
01079     while(time_incr--)
01080         put_bits(&s->pb, 1, 1);
01081 
01082     put_bits(&s->pb, 1, 0);
01083 
01084     put_bits(&s->pb, 1, 1);                             /* marker */
01085     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
01086     put_bits(&s->pb, 1, 1);                             /* marker */
01087     put_bits(&s->pb, 1, 1);                             /* vop coded */
01088     if (    s->pict_type == FF_P_TYPE
01089         || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
01090         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
01091     }
01092     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
01093     if(!s->progressive_sequence){
01094          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
01095          put_bits(&s->pb, 1, s->alternate_scan);
01096     }
01097     //FIXME sprite stuff
01098 
01099     put_bits(&s->pb, 5, s->qscale);
01100 
01101     if (s->pict_type != FF_I_TYPE)
01102         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
01103     if (s->pict_type == FF_B_TYPE)
01104         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
01105 }
01106 
01107 
01108 static void init_uni_dc_tab(void)
01109 {
01110     int level, uni_code, uni_len;
01111 
01112     for(level=-256; level<256; level++){
01113         int size, v, l;
01114         /* find number of bits */
01115         size = 0;
01116         v = abs(level);
01117         while (v) {
01118             v >>= 1;
01119             size++;
01120         }
01121 
01122         if (level < 0)
01123             l= (-level) ^ ((1 << size) - 1);
01124         else
01125             l= level;
01126 
01127         /* luminance */
01128         uni_code= ff_mpeg4_DCtab_lum[size][0];
01129         uni_len = ff_mpeg4_DCtab_lum[size][1];
01130 
01131         if (size > 0) {
01132             uni_code<<=size; uni_code|=l;
01133             uni_len+=size;
01134             if (size > 8){
01135                 uni_code<<=1; uni_code|=1;
01136                 uni_len++;
01137             }
01138         }
01139         uni_DCtab_lum_bits[level+256]= uni_code;
01140         uni_DCtab_lum_len [level+256]= uni_len;
01141 
01142         /* chrominance */
01143         uni_code= ff_mpeg4_DCtab_chrom[size][0];
01144         uni_len = ff_mpeg4_DCtab_chrom[size][1];
01145 
01146         if (size > 0) {
01147             uni_code<<=size; uni_code|=l;
01148             uni_len+=size;
01149             if (size > 8){
01150                 uni_code<<=1; uni_code|=1;
01151                 uni_len++;
01152             }
01153         }
01154         uni_DCtab_chrom_bits[level+256]= uni_code;
01155         uni_DCtab_chrom_len [level+256]= uni_len;
01156 
01157     }
01158 }
01159 
01160 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01161     int slevel, run, last;
01162 
01163     assert(MAX_LEVEL >= 64);
01164     assert(MAX_RUN   >= 63);
01165 
01166     for(slevel=-64; slevel<64; slevel++){
01167         if(slevel==0) continue;
01168         for(run=0; run<64; run++){
01169             for(last=0; last<=1; last++){
01170                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
01171                 int level= slevel < 0 ? -slevel : slevel;
01172                 int sign= slevel < 0 ? 1 : 0;
01173                 int bits, len, code;
01174                 int level1, run1;
01175 
01176                 len_tab[index]= 100;
01177 
01178                 /* ESC0 */
01179                 code= get_rl_index(rl, last, run, level);
01180                 bits= rl->table_vlc[code][0];
01181                 len=  rl->table_vlc[code][1];
01182                 bits=bits*2+sign; len++;
01183 
01184                 if(code!=rl->n && len < len_tab[index]){
01185                     bits_tab[index]= bits;
01186                     len_tab [index]= len;
01187                 }
01188                 /* ESC1 */
01189                 bits= rl->table_vlc[rl->n][0];
01190                 len=  rl->table_vlc[rl->n][1];
01191                 bits=bits*2;    len++; //esc1
01192                 level1= level - rl->max_level[last][run];
01193                 if(level1>0){
01194                     code= get_rl_index(rl, last, run, level1);
01195                     bits<<= rl->table_vlc[code][1];
01196                     len  += rl->table_vlc[code][1];
01197                     bits += rl->table_vlc[code][0];
01198                     bits=bits*2+sign; len++;
01199 
01200                     if(code!=rl->n && len < len_tab[index]){
01201                         bits_tab[index]= bits;
01202                         len_tab [index]= len;
01203                     }
01204                 }
01205                 /* ESC2 */
01206                 bits= rl->table_vlc[rl->n][0];
01207                 len=  rl->table_vlc[rl->n][1];
01208                 bits=bits*4+2;    len+=2; //esc2
01209                 run1 = run - rl->max_run[last][level] - 1;
01210                 if(run1>=0){
01211                     code= get_rl_index(rl, last, run1, level);
01212                     bits<<= rl->table_vlc[code][1];
01213                     len  += rl->table_vlc[code][1];
01214                     bits += rl->table_vlc[code][0];
01215                     bits=bits*2+sign; len++;
01216 
01217                     if(code!=rl->n && len < len_tab[index]){
01218                         bits_tab[index]= bits;
01219                         len_tab [index]= len;
01220                     }
01221                 }
01222                 /* ESC3 */
01223                 bits= rl->table_vlc[rl->n][0];
01224                 len = rl->table_vlc[rl->n][1];
01225                 bits=bits*4+3;    len+=2; //esc3
01226                 bits=bits*2+last; len++;
01227                 bits=bits*64+run; len+=6;
01228                 bits=bits*2+1;    len++;  //marker
01229                 bits=bits*4096+(slevel&0xfff); len+=12;
01230                 bits=bits*2+1;    len++;  //marker
01231 
01232                 if(len < len_tab[index]){
01233                     bits_tab[index]= bits;
01234                     len_tab [index]= len;
01235                 }
01236             }
01237         }
01238     }
01239 }
01240 
01241 static av_cold int encode_init(AVCodecContext *avctx)
01242 {
01243     MpegEncContext *s = avctx->priv_data;
01244     int ret;
01245     static int done = 0;
01246 
01247     if((ret=MPV_encode_init(avctx)) < 0)
01248         return ret;
01249 
01250     if (!done) {
01251         done = 1;
01252 
01253         init_uni_dc_tab();
01254 
01255         init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
01256 
01257         init_uni_mpeg4_rl_tab(&ff_mpeg4_rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
01258         init_uni_mpeg4_rl_tab(&ff_h263_rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
01259     }
01260 
01261     s->min_qcoeff= -2048;
01262     s->max_qcoeff=  2047;
01263     s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
01264     s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
01265     s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
01266     s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
01267     s->luma_dc_vlc_length= uni_DCtab_lum_len;
01268     s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
01269     s->ac_esc_length= 7+2+1+6+1+12+1;
01270     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
01271     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
01272 
01273     if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
01274 
01275         s->avctx->extradata= av_malloc(1024);
01276         init_put_bits(&s->pb, s->avctx->extradata, 1024);
01277 
01278         if(!(s->workaround_bugs & FF_BUG_MS))
01279             mpeg4_encode_visual_object_header(s);
01280         mpeg4_encode_vol_header(s, 0, 0);
01281 
01282 //            ff_mpeg4_stuffing(&s->pb); ?
01283         flush_put_bits(&s->pb);
01284         s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
01285     }
01286     return 0;
01287 }
01288 
01289 void ff_mpeg4_init_partitions(MpegEncContext *s)
01290 {
01291     uint8_t *start= put_bits_ptr(&s->pb);
01292     uint8_t *end= s->pb.buf_end;
01293     int size= end - start;
01294     int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start;
01295     int tex_size= (size - 2*pb_size)&(~3);
01296 
01297     set_put_bits_buffer_size(&s->pb, pb_size);
01298     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
01299     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
01300 }
01301 
01302 void ff_mpeg4_merge_partitions(MpegEncContext *s)
01303 {
01304     const int pb2_len   = put_bits_count(&s->pb2   );
01305     const int tex_pb_len= put_bits_count(&s->tex_pb);
01306     const int bits= put_bits_count(&s->pb);
01307 
01308     if(s->pict_type==FF_I_TYPE){
01309         put_bits(&s->pb, 19, DC_MARKER);
01310         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
01311         s->i_tex_bits+= tex_pb_len;
01312     }else{
01313         put_bits(&s->pb, 17, MOTION_MARKER);
01314         s->misc_bits+=17 + pb2_len;
01315         s->mv_bits+= bits - s->last_bits;
01316         s->p_tex_bits+= tex_pb_len;
01317     }
01318 
01319     flush_put_bits(&s->pb2);
01320     flush_put_bits(&s->tex_pb);
01321 
01322     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
01323     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
01324     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
01325     s->last_bits= put_bits_count(&s->pb);
01326 }
01327 
01328 
01329 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
01330 {
01331     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
01332 
01333     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
01334     put_bits(&s->pb, 1, 1);
01335 
01336     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
01337     put_bits(&s->pb, s->quant_precision, s->qscale);
01338     put_bits(&s->pb, 1, 0); /* no HEC */
01339 }
01340 
01341 AVCodec mpeg4_encoder = {
01342     "mpeg4",
01343     AVMEDIA_TYPE_VIDEO,
01344     CODEC_ID_MPEG4,
01345     sizeof(MpegEncContext),
01346     encode_init,
01347     MPV_encode_picture,
01348     MPV_encode_end,
01349     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
01350     .capabilities= CODEC_CAP_DELAY,
01351     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
01352 };

Generated on Fri Sep 16 2011 17:17:40 for FFmpeg by  doxygen 1.7.1