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

libavcodec/msmpeg4.c

Go to the documentation of this file.
00001 /*
00002  * MSMPEG4 backend for ffmpeg encoder and decoder
00003  * Copyright (c) 2001 Fabrice Bellard
00004  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
00005  *
00006  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
00007  *
00008  * This file is part of FFmpeg.
00009  *
00010  * FFmpeg is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free Software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  *
00015  * FFmpeg is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with FFmpeg; if not, write to the Free Software
00022  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00023  */
00024 
00030 #include "avcodec.h"
00031 #include "dsputil.h"
00032 #include "mpegvideo.h"
00033 #include "msmpeg4.h"
00034 
00035 /*
00036  * You can also call this codec : MPEG4 with a twist !
00037  *
00038  * TODO:
00039  *        - (encoding) select best mv table (two choices)
00040  *        - (encoding) select best vlc/dc table
00041  */
00042 //#define DEBUG
00043 
00044 #define DC_VLC_BITS 9
00045 #define CBPY_VLC_BITS 6
00046 #define V1_INTRA_CBPC_VLC_BITS 6
00047 #define V1_INTER_CBPC_VLC_BITS 6
00048 #define V2_INTRA_CBPC_VLC_BITS 3
00049 #define V2_MB_TYPE_VLC_BITS 7
00050 #define MV_VLC_BITS 9
00051 #define V2_MV_VLC_BITS 9
00052 #define TEX_VLC_BITS 9
00053 
00054 #define II_BITRATE 128*1024
00055 #define MBAC_BITRATE 50*1024
00056 
00057 #define DEFAULT_INTER_INDEX 3
00058 
00059 static uint32_t v2_dc_lum_table[512][2];
00060 static uint32_t v2_dc_chroma_table[512][2];
00061 
00062 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
00063 static void init_h263_dc_for_msmpeg4(void);
00064 static inline void msmpeg4_memsetw(short *tab, int val, int n);
00065 #if CONFIG_ENCODERS
00066 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
00067 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
00068 #endif //CONFIG_ENCODERS
00069 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
00070 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
00071 
00072 /* vc1 externs */
00073 extern const uint8_t wmv3_dc_scale_table[32];
00074 
00075 #ifdef DEBUG
00076 int intra_count = 0;
00077 int frame_count = 0;
00078 #endif
00079 
00080 #include "msmpeg4data.h"
00081 
00082 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
00083 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
00084 #endif //CONFIG_ENCODERS
00085 
00086 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
00087 
00088 static av_cold void common_init(MpegEncContext * s)
00089 {
00090     static int initialized=0;
00091 
00092     switch(s->msmpeg4_version){
00093     case 1:
00094     case 2:
00095         s->y_dc_scale_table=
00096         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00097         break;
00098     case 3:
00099         if(s->workaround_bugs){
00100             s->y_dc_scale_table= old_ff_y_dc_scale_table;
00101             s->c_dc_scale_table= wmv1_c_dc_scale_table;
00102         } else{
00103             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
00104             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
00105         }
00106         break;
00107     case 4:
00108     case 5:
00109         s->y_dc_scale_table= wmv1_y_dc_scale_table;
00110         s->c_dc_scale_table= wmv1_c_dc_scale_table;
00111         break;
00112 #if CONFIG_WMV3_DECODER || CONFIG_VC1_DECODER
00113     case 6:
00114         s->y_dc_scale_table= wmv3_dc_scale_table;
00115         s->c_dc_scale_table= wmv3_dc_scale_table;
00116         break;
00117 #endif
00118 
00119     }
00120 
00121 
00122     if(s->msmpeg4_version>=4){
00123         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
00124         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
00125         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
00126         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
00127     }
00128     //Note the default tables are set in common_init in mpegvideo.c
00129 
00130     if(!initialized){
00131         initialized=1;
00132 
00133         init_h263_dc_for_msmpeg4();
00134     }
00135 }
00136 
00137 #if CONFIG_ENCODERS
00138 
00139 /* build the table which associate a (x,y) motion vector to a vlc */
00140 static void init_mv_table(MVTable *tab)
00141 {
00142     int i, x, y;
00143 
00144     tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
00145     /* mark all entries as not used */
00146     for(i=0;i<4096;i++)
00147         tab->table_mv_index[i] = tab->n;
00148 
00149     for(i=0;i<tab->n;i++) {
00150         x = tab->table_mvx[i];
00151         y = tab->table_mvy[i];
00152         tab->table_mv_index[(x << 6) | y] = i;
00153     }
00154 }
00155 
00156 void ff_msmpeg4_code012(PutBitContext *pb, int n)
00157 {
00158     if (n == 0) {
00159         put_bits(pb, 1, 0);
00160     } else {
00161         put_bits(pb, 1, 1);
00162         put_bits(pb, 1, (n >= 2));
00163     }
00164 }
00165 
00166 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
00167 {
00168     static int init_done=0;
00169     int i;
00170 
00171     common_init(s);
00172     if(s->msmpeg4_version>=4){
00173         s->min_qcoeff= -255;
00174         s->max_qcoeff=  255;
00175     }
00176 
00177     if (!init_done) {
00178         /* init various encoding tables */
00179         init_done = 1;
00180         init_mv_table(&mv_tables[0]);
00181         init_mv_table(&mv_tables[1]);
00182         for(i=0;i<NB_RL_TABLES;i++)
00183             init_rl(&rl_table[i], static_rl_table_store[i]);
00184 
00185         for(i=0; i<NB_RL_TABLES; i++){
00186             int level;
00187             for(level=0; level<=MAX_LEVEL; level++){
00188                 int run;
00189                 for(run=0; run<=MAX_RUN; run++){
00190                     int last;
00191                     for(last=0; last<2; last++){
00192                         rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
00193                     }
00194                 }
00195             }
00196         }
00197     }
00198 }
00199 
00200 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
00201     int size=0;
00202     int code;
00203     int run_diff= intra ? 0 : 1;
00204 
00205     code = get_rl_index(rl, last, run, level);
00206     size+= rl->table_vlc[code][1];
00207     if (code == rl->n) {
00208         int level1, run1;
00209 
00210         level1 = level - rl->max_level[last][run];
00211         if (level1 < 1)
00212             goto esc2;
00213         code = get_rl_index(rl, last, run, level1);
00214         if (code == rl->n) {
00215             esc2:
00216             size++;
00217             if (level > MAX_LEVEL)
00218                 goto esc3;
00219             run1 = run - rl->max_run[last][level] - run_diff;
00220             if (run1 < 0)
00221                 goto esc3;
00222             code = get_rl_index(rl, last, run1, level);
00223             if (code == rl->n) {
00224             esc3:
00225                 /* third escape */
00226                 size+=1+1+6+8;
00227             } else {
00228                 /* second escape */
00229                 size+= 1+1+ rl->table_vlc[code][1];
00230             }
00231         } else {
00232             /* first escape */
00233             size+= 1+1+ rl->table_vlc[code][1];
00234         }
00235     } else {
00236         size++;
00237     }
00238     return size;
00239 }
00240 
00241 static void find_best_tables(MpegEncContext * s)
00242 {
00243     int i;
00244     int best       =-1, best_size       =9999999;
00245     int chroma_best=-1, best_chroma_size=9999999;
00246 
00247     for(i=0; i<3; i++){
00248         int level;
00249         int chroma_size=0;
00250         int size=0;
00251 
00252         if(i>0){// ;)
00253             size++;
00254             chroma_size++;
00255         }
00256         for(level=0; level<=MAX_LEVEL; level++){
00257             int run;
00258             for(run=0; run<=MAX_RUN; run++){
00259                 int last;
00260                 const int last_size= size + chroma_size;
00261                 for(last=0; last<2; last++){
00262                     int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
00263                     int intra_luma_count  = s->ac_stats[1][0][level][run][last];
00264                     int intra_chroma_count= s->ac_stats[1][1][level][run][last];
00265 
00266                     if(s->pict_type==FF_I_TYPE){
00267                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
00268                         chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
00269                     }else{
00270                         size+=        intra_luma_count  *rl_length[i  ][level][run][last]
00271                                      +intra_chroma_count*rl_length[i+3][level][run][last]
00272                                      +inter_count       *rl_length[i+3][level][run][last];
00273                     }
00274                 }
00275                 if(last_size == size+chroma_size) break;
00276             }
00277         }
00278         if(size<best_size){
00279             best_size= size;
00280             best= i;
00281         }
00282         if(chroma_size<best_chroma_size){
00283             best_chroma_size= chroma_size;
00284             chroma_best= i;
00285         }
00286     }
00287 
00288 //    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
00289 //           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
00290 
00291     if(s->pict_type==FF_P_TYPE) chroma_best= best;
00292 
00293     memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
00294 
00295     s->rl_table_index       =        best;
00296     s->rl_chroma_table_index= chroma_best;
00297 
00298     if(s->pict_type != s->last_non_b_pict_type){
00299         s->rl_table_index= 2;
00300         if(s->pict_type==FF_I_TYPE)
00301             s->rl_chroma_table_index= 1;
00302         else
00303             s->rl_chroma_table_index= 2;
00304     }
00305 
00306 }
00307 
00308 /* write MSMPEG4 compatible frame header */
00309 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
00310 {
00311     find_best_tables(s);
00312 
00313     align_put_bits(&s->pb);
00314     put_bits(&s->pb, 2, s->pict_type - 1);
00315 
00316     put_bits(&s->pb, 5, s->qscale);
00317     if(s->msmpeg4_version<=2){
00318         s->rl_table_index = 2;
00319         s->rl_chroma_table_index = 2;
00320     }
00321 
00322     s->dc_table_index = 1;
00323     s->mv_table_index = 1; /* only if P frame */
00324     s->use_skip_mb_code = 1; /* only if P frame */
00325     s->per_mb_rl_table = 0;
00326     if(s->msmpeg4_version==4)
00327         s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
00328 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
00329 
00330     if (s->pict_type == FF_I_TYPE) {
00331         s->slice_height= s->mb_height/1;
00332         put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
00333 
00334         if(s->msmpeg4_version==4){
00335             msmpeg4_encode_ext_header(s);
00336             if(s->bit_rate>MBAC_BITRATE)
00337                 put_bits(&s->pb, 1, s->per_mb_rl_table);
00338         }
00339 
00340         if(s->msmpeg4_version>2){
00341             if(!s->per_mb_rl_table){
00342                 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
00343                 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
00344             }
00345 
00346             put_bits(&s->pb, 1, s->dc_table_index);
00347         }
00348     } else {
00349         put_bits(&s->pb, 1, s->use_skip_mb_code);
00350 
00351         if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
00352             put_bits(&s->pb, 1, s->per_mb_rl_table);
00353 
00354         if(s->msmpeg4_version>2){
00355             if(!s->per_mb_rl_table)
00356                 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
00357 
00358             put_bits(&s->pb, 1, s->dc_table_index);
00359 
00360             put_bits(&s->pb, 1, s->mv_table_index);
00361         }
00362     }
00363 
00364     s->esc3_level_length= 0;
00365     s->esc3_run_length= 0;
00366 
00367 #ifdef DEBUG
00368     intra_count = 0;
00369     av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
00370 #endif
00371 }
00372 
00373 void msmpeg4_encode_ext_header(MpegEncContext * s)
00374 {
00375         put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
00376 
00377         put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
00378 
00379         if(s->msmpeg4_version>=3)
00380             put_bits(&s->pb, 1, s->flipflop_rounding);
00381         else
00382             assert(s->flipflop_rounding==0);
00383 }
00384 
00385 #endif //CONFIG_ENCODERS
00386 
00387 /* predict coded block */
00388 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
00389 {
00390     int xy, wrap, pred, a, b, c;
00391 
00392     xy = s->block_index[n];
00393     wrap = s->b8_stride;
00394 
00395     /* B C
00396      * A X
00397      */
00398     a = s->coded_block[xy - 1       ];
00399     b = s->coded_block[xy - 1 - wrap];
00400     c = s->coded_block[xy     - wrap];
00401 
00402     if (b == c) {
00403         pred = a;
00404     } else {
00405         pred = c;
00406     }
00407 
00408     /* store value */
00409     *coded_block_ptr = &s->coded_block[xy];
00410 
00411     return pred;
00412 }
00413 
00414 #if CONFIG_ENCODERS
00415 
00416 void ff_msmpeg4_encode_motion(MpegEncContext * s,
00417                                   int mx, int my)
00418 {
00419     int code;
00420     MVTable *mv;
00421 
00422     /* modulo encoding */
00423     /* WARNING : you cannot reach all the MVs even with the modulo
00424        encoding. This is a somewhat strange compromise they took !!!  */
00425     if (mx <= -64)
00426         mx += 64;
00427     else if (mx >= 64)
00428         mx -= 64;
00429     if (my <= -64)
00430         my += 64;
00431     else if (my >= 64)
00432         my -= 64;
00433 
00434     mx += 32;
00435     my += 32;
00436 #if 0
00437     if ((unsigned)mx >= 64 ||
00438         (unsigned)my >= 64)
00439         av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
00440 #endif
00441     mv = &mv_tables[s->mv_table_index];
00442 
00443     code = mv->table_mv_index[(mx << 6) | my];
00444     put_bits(&s->pb,
00445              mv->table_mv_bits[code],
00446              mv->table_mv_code[code]);
00447     if (code == mv->n) {
00448         /* escape : code literally */
00449         put_bits(&s->pb, 6, mx);
00450         put_bits(&s->pb, 6, my);
00451     }
00452 }
00453 
00454 void ff_msmpeg4_handle_slices(MpegEncContext *s){
00455     if (s->mb_x == 0) {
00456         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
00457             if(s->msmpeg4_version < 4){
00458                 ff_mpeg4_clean_buffers(s);
00459             }
00460             s->first_slice_line = 1;
00461         } else {
00462             s->first_slice_line = 0;
00463         }
00464     }
00465 }
00466 
00467 void msmpeg4_encode_mb(MpegEncContext * s,
00468                        DCTELEM block[6][64],
00469                        int motion_x, int motion_y)
00470 {
00471     int cbp, coded_cbp, i;
00472     int pred_x, pred_y;
00473     uint8_t *coded_block;
00474 
00475     ff_msmpeg4_handle_slices(s);
00476 
00477     if (!s->mb_intra) {
00478         /* compute cbp */
00479         cbp = 0;
00480         for (i = 0; i < 6; i++) {
00481             if (s->block_last_index[i] >= 0)
00482                 cbp |= 1 << (5 - i);
00483         }
00484         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
00485             /* skip macroblock */
00486             put_bits(&s->pb, 1, 1);
00487             s->last_bits++;
00488             s->misc_bits++;
00489             s->skip_count++;
00490 
00491             return;
00492         }
00493         if (s->use_skip_mb_code)
00494             put_bits(&s->pb, 1, 0);     /* mb coded */
00495 
00496         if(s->msmpeg4_version<=2){
00497             put_bits(&s->pb,
00498                      v2_mb_type[cbp&3][1],
00499                      v2_mb_type[cbp&3][0]);
00500             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
00501             else             coded_cbp= cbp;
00502 
00503             put_bits(&s->pb,
00504                      cbpy_tab[coded_cbp>>2][1],
00505                      cbpy_tab[coded_cbp>>2][0]);
00506 
00507             s->misc_bits += get_bits_diff(s);
00508 
00509             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00510             msmpeg4v2_encode_motion(s, motion_x - pred_x);
00511             msmpeg4v2_encode_motion(s, motion_y - pred_y);
00512         }else{
00513             put_bits(&s->pb,
00514                      table_mb_non_intra[cbp + 64][1],
00515                      table_mb_non_intra[cbp + 64][0]);
00516 
00517             s->misc_bits += get_bits_diff(s);
00518 
00519             /* motion vector */
00520             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00521             ff_msmpeg4_encode_motion(s, motion_x - pred_x,
00522                                   motion_y - pred_y);
00523         }
00524 
00525         s->mv_bits += get_bits_diff(s);
00526 
00527         for (i = 0; i < 6; i++) {
00528             ff_msmpeg4_encode_block(s, block[i], i);
00529         }
00530         s->p_tex_bits += get_bits_diff(s);
00531     } else {
00532         /* compute cbp */
00533         cbp = 0;
00534         coded_cbp = 0;
00535         for (i = 0; i < 6; i++) {
00536             int val, pred;
00537             val = (s->block_last_index[i] >= 1);
00538             cbp |= val << (5 - i);
00539             if (i < 4) {
00540                 /* predict value for close blocks only for luma */
00541                 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
00542                 *coded_block = val;
00543                 val = val ^ pred;
00544             }
00545             coded_cbp |= val << (5 - i);
00546         }
00547 #if 0
00548         if (coded_cbp)
00549             printf("cbp=%x %x\n", cbp, coded_cbp);
00550 #endif
00551 
00552         if(s->msmpeg4_version<=2){
00553             if (s->pict_type == FF_I_TYPE) {
00554                 put_bits(&s->pb,
00555                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
00556             } else {
00557                 if (s->use_skip_mb_code)
00558                     put_bits(&s->pb, 1, 0);     /* mb coded */
00559                 put_bits(&s->pb,
00560                          v2_mb_type[(cbp&3) + 4][1],
00561                          v2_mb_type[(cbp&3) + 4][0]);
00562             }
00563             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
00564             put_bits(&s->pb,
00565                      cbpy_tab[cbp>>2][1],
00566                      cbpy_tab[cbp>>2][0]);
00567         }else{
00568             if (s->pict_type == FF_I_TYPE) {
00569                 put_bits(&s->pb,
00570                          ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
00571             } else {
00572                 if (s->use_skip_mb_code)
00573                     put_bits(&s->pb, 1, 0);     /* mb coded */
00574                 put_bits(&s->pb,
00575                          table_mb_non_intra[cbp][1],
00576                          table_mb_non_intra[cbp][0]);
00577             }
00578             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
00579             if(s->inter_intra_pred){
00580                 s->h263_aic_dir=0;
00581                 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
00582             }
00583         }
00584         s->misc_bits += get_bits_diff(s);
00585 
00586         for (i = 0; i < 6; i++) {
00587             ff_msmpeg4_encode_block(s, block[i], i);
00588         }
00589         s->i_tex_bits += get_bits_diff(s);
00590         s->i_count++;
00591     }
00592 }
00593 
00594 #endif //CONFIG_ENCODERS
00595 
00596 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
00597                                     int32_t **dc_val_ptr)
00598 {
00599     int i;
00600 
00601     if (n < 4) {
00602         i= 0;
00603     } else {
00604         i= n-3;
00605     }
00606 
00607     *dc_val_ptr= &s->last_dc[i];
00608     return s->last_dc[i];
00609 }
00610 
00611 static int get_dc(uint8_t *src, int stride, int scale)
00612 {
00613     int y;
00614     int sum=0;
00615     for(y=0; y<8; y++){
00616         int x;
00617         for(x=0; x<8; x++){
00618             sum+=src[x + y*stride];
00619         }
00620     }
00621     return FASTDIV((sum + (scale>>1)), scale);
00622 }
00623 
00624 /* dir = 0: left, dir = 1: top prediction */
00625 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
00626                              int16_t **dc_val_ptr, int *dir_ptr)
00627 {
00628     int a, b, c, wrap, pred, scale;
00629     int16_t *dc_val;
00630 
00631     /* find prediction */
00632     if (n < 4) {
00633         scale = s->y_dc_scale;
00634     } else {
00635         scale = s->c_dc_scale;
00636     }
00637 
00638     wrap = s->block_wrap[n];
00639     dc_val= s->dc_val[0] + s->block_index[n];
00640 
00641     /* B C
00642      * A X
00643      */
00644     a = dc_val[ - 1];
00645     b = dc_val[ - 1 - wrap];
00646     c = dc_val[ - wrap];
00647 
00648     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
00649         b=c=1024;
00650     }
00651 
00652     /* XXX: the following solution consumes divisions, but it does not
00653        necessitate to modify mpegvideo.c. The problem comes from the
00654        fact they decided to store the quantized DC (which would lead
00655        to problems if Q could vary !) */
00656 #if ARCH_X86 && !defined PIC
00657     __asm__ volatile(
00658         "movl %3, %%eax         \n\t"
00659         "shrl $1, %%eax         \n\t"
00660         "addl %%eax, %2         \n\t"
00661         "addl %%eax, %1         \n\t"
00662         "addl %0, %%eax         \n\t"
00663         "mull %4                \n\t"
00664         "movl %%edx, %0         \n\t"
00665         "movl %1, %%eax         \n\t"
00666         "mull %4                \n\t"
00667         "movl %%edx, %1         \n\t"
00668         "movl %2, %%eax         \n\t"
00669         "mull %4                \n\t"
00670         "movl %%edx, %2         \n\t"
00671         : "+b" (a), "+c" (b), "+D" (c)
00672         : "g" (scale), "S" (ff_inverse[scale])
00673         : "%eax", "%edx"
00674     );
00675 #else
00676     /* #elif ARCH_ALPHA */
00677     /* Divisions are extremely costly on Alpha; optimize the most
00678        common case. But they are costly everywhere...
00679      */
00680     if (scale == 8) {
00681         a = (a + (8 >> 1)) / 8;
00682         b = (b + (8 >> 1)) / 8;
00683         c = (c + (8 >> 1)) / 8;
00684     } else {
00685         a = FASTDIV((a + (scale >> 1)), scale);
00686         b = FASTDIV((b + (scale >> 1)), scale);
00687         c = FASTDIV((c + (scale >> 1)), scale);
00688     }
00689 #endif
00690     /* XXX: WARNING: they did not choose the same test as MPEG4. This
00691        is very important ! */
00692     if(s->msmpeg4_version>3){
00693         if(s->inter_intra_pred){
00694             uint8_t *dest;
00695             int wrap;
00696 
00697             if(n==1){
00698                 pred=a;
00699                 *dir_ptr = 0;
00700             }else if(n==2){
00701                 pred=c;
00702                 *dir_ptr = 1;
00703             }else if(n==3){
00704                 if (abs(a - b) < abs(b - c)) {
00705                     pred = c;
00706                     *dir_ptr = 1;
00707                 } else {
00708                     pred = a;
00709                     *dir_ptr = 0;
00710                 }
00711             }else{
00712                 if(n<4){
00713                     wrap= s->linesize;
00714                     dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
00715                 }else{
00716                     wrap= s->uvlinesize;
00717                     dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
00718                 }
00719                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
00720                 else           a= get_dc(dest-8, wrap, scale*8);
00721                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
00722                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
00723 
00724                 if (s->h263_aic_dir==0) {
00725                     pred= a;
00726                     *dir_ptr = 0;
00727                 }else if (s->h263_aic_dir==1) {
00728                     if(n==0){
00729                         pred= c;
00730                         *dir_ptr = 1;
00731                     }else{
00732                         pred= a;
00733                         *dir_ptr = 0;
00734                     }
00735                 }else if (s->h263_aic_dir==2) {
00736                     if(n==0){
00737                         pred= a;
00738                         *dir_ptr = 0;
00739                     }else{
00740                         pred= c;
00741                         *dir_ptr = 1;
00742                     }
00743                 } else {
00744                     pred= c;
00745                     *dir_ptr = 1;
00746                 }
00747             }
00748         }else{
00749             if (abs(a - b) < abs(b - c)) {
00750                 pred = c;
00751                 *dir_ptr = 1;
00752             } else {
00753                 pred = a;
00754                 *dir_ptr = 0;
00755             }
00756         }
00757     }else{
00758         if (abs(a - b) <= abs(b - c)) {
00759             pred = c;
00760             *dir_ptr = 1;
00761         } else {
00762             pred = a;
00763             *dir_ptr = 0;
00764         }
00765     }
00766 
00767     /* update predictor */
00768     *dc_val_ptr = &dc_val[0];
00769     return pred;
00770 }
00771 
00772 #define DC_MAX 119
00773 
00774 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
00775 {
00776     int sign, code;
00777     int pred, extquant;
00778     int extrabits = 0;
00779 
00780     if(s->msmpeg4_version==1){
00781         int32_t *dc_val;
00782         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
00783 
00784         /* update predictor */
00785         *dc_val= level;
00786     }else{
00787         int16_t *dc_val;
00788         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
00789 
00790         /* update predictor */
00791         if (n < 4) {
00792             *dc_val = level * s->y_dc_scale;
00793         } else {
00794             *dc_val = level * s->c_dc_scale;
00795         }
00796     }
00797 
00798     /* do the prediction */
00799     level -= pred;
00800 
00801     if(s->msmpeg4_version<=2){
00802         if (n < 4) {
00803             put_bits(&s->pb,
00804                      v2_dc_lum_table[level+256][1],
00805                      v2_dc_lum_table[level+256][0]);
00806         }else{
00807             put_bits(&s->pb,
00808                      v2_dc_chroma_table[level+256][1],
00809                      v2_dc_chroma_table[level+256][0]);
00810         }
00811     }else{
00812         sign = 0;
00813         if (level < 0) {
00814             level = -level;
00815             sign = 1;
00816         }
00817         code = level;
00818         if (code > DC_MAX)
00819             code = DC_MAX;
00820         else if( s->msmpeg4_version>=6 ) {
00821             if( s->qscale == 1 ) {
00822                 extquant = (level + 3) & 0x3;
00823                 code  = ((level+3)>>2);
00824             } else if( s->qscale == 2 ) {
00825                 extquant = (level + 1) & 0x1;
00826                 code  = ((level+1)>>1);
00827             }
00828         }
00829 
00830         if (s->dc_table_index == 0) {
00831             if (n < 4) {
00832                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
00833             } else {
00834                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
00835             }
00836         } else {
00837             if (n < 4) {
00838                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
00839             } else {
00840                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
00841             }
00842         }
00843 
00844         if(s->msmpeg4_version>=6 && s->qscale<=2)
00845             extrabits = 3 - s->qscale;
00846 
00847         if (code == DC_MAX)
00848             put_bits(&s->pb, 8 + extrabits, level);
00849         else if(extrabits > 0)//== VC1 && s->qscale<=2
00850             put_bits(&s->pb, extrabits, extquant);
00851 
00852         if (level != 0) {
00853             put_bits(&s->pb, 1, sign);
00854         }
00855     }
00856 }
00857 
00858 /* Encoding of a block. Very similar to MPEG4 except for a different
00859    escape coding (same as H263) and more vlc tables.
00860  */
00861 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
00862 {
00863     int level, run, last, i, j, last_index;
00864     int last_non_zero, sign, slevel;
00865     int code, run_diff, dc_pred_dir;
00866     const RLTable *rl;
00867     const uint8_t *scantable;
00868 
00869     if (s->mb_intra) {
00870         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
00871         i = 1;
00872         if (n < 4) {
00873             rl = &rl_table[s->rl_table_index];
00874         } else {
00875             rl = &rl_table[3 + s->rl_chroma_table_index];
00876         }
00877         run_diff = s->msmpeg4_version>=4;
00878         scantable= s->intra_scantable.permutated;
00879     } else {
00880         i = 0;
00881         rl = &rl_table[3 + s->rl_table_index];
00882         if(s->msmpeg4_version<=2)
00883             run_diff = 0;
00884         else
00885             run_diff = 1;
00886         scantable= s->inter_scantable.permutated;
00887     }
00888 
00889     /* recalculate block_last_index for M$ wmv1 */
00890     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
00891         for(last_index=63; last_index>=0; last_index--){
00892             if(block[scantable[last_index]]) break;
00893         }
00894         s->block_last_index[n]= last_index;
00895     }else
00896         last_index = s->block_last_index[n];
00897     /* AC coefs */
00898     last_non_zero = i - 1;
00899     for (; i <= last_index; i++) {
00900         j = scantable[i];
00901         level = block[j];
00902         if (level) {
00903             run = i - last_non_zero - 1;
00904             last = (i == last_index);
00905             sign = 0;
00906             slevel = level;
00907             if (level < 0) {
00908                 sign = 1;
00909                 level = -level;
00910             }
00911 
00912             if(level<=MAX_LEVEL && run<=MAX_RUN){
00913                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
00914             }
00915 #if 0
00916 else
00917     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
00918 #endif
00919             code = get_rl_index(rl, last, run, level);
00920             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00921             if (code == rl->n) {
00922                 int level1, run1;
00923 
00924                 level1 = level - rl->max_level[last][run];
00925                 if (level1 < 1)
00926                     goto esc2;
00927                 code = get_rl_index(rl, last, run, level1);
00928                 if (code == rl->n) {
00929                 esc2:
00930                     put_bits(&s->pb, 1, 0);
00931                     if (level > MAX_LEVEL)
00932                         goto esc3;
00933                     run1 = run - rl->max_run[last][level] - run_diff;
00934                     if (run1 < 0)
00935                         goto esc3;
00936                     code = get_rl_index(rl, last, run1+1, level);
00937                     if (s->msmpeg4_version == 4 && code == rl->n)
00938                         goto esc3;
00939                     code = get_rl_index(rl, last, run1, level);
00940                     if (code == rl->n) {
00941                     esc3:
00942                         /* third escape */
00943                         put_bits(&s->pb, 1, 0);
00944                         put_bits(&s->pb, 1, last);
00945                         if(s->msmpeg4_version>=4){
00946                             if(s->esc3_level_length==0){
00947                                 s->esc3_level_length=8;
00948                                 s->esc3_run_length= 6;
00949                                 //ESCLVLSZ + ESCRUNSZ
00950                                 if(s->qscale<8)
00951                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
00952                                 else
00953                                     put_bits(&s->pb, 8, 3);
00954                             }
00955                             put_bits(&s->pb, s->esc3_run_length, run);
00956                             put_bits(&s->pb, 1, sign);
00957                             put_bits(&s->pb, s->esc3_level_length, level);
00958                         }else{
00959                             put_bits(&s->pb, 6, run);
00960                             put_sbits(&s->pb, 8, slevel);
00961                         }
00962                     } else {
00963                         /* second escape */
00964                         put_bits(&s->pb, 1, 1);
00965                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00966                         put_bits(&s->pb, 1, sign);
00967                     }
00968                 } else {
00969                     /* first escape */
00970                     put_bits(&s->pb, 1, 1);
00971                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00972                     put_bits(&s->pb, 1, sign);
00973                 }
00974             } else {
00975                 put_bits(&s->pb, 1, sign);
00976             }
00977             last_non_zero = i;
00978         }
00979     }
00980 }
00981 
00982 /****************************************/
00983 /* decoding stuff */
00984 
00985 VLC ff_mb_non_intra_vlc[4];
00986 static VLC v2_dc_lum_vlc;
00987 static VLC v2_dc_chroma_vlc;
00988 static VLC cbpy_vlc;
00989 static VLC v2_intra_cbpc_vlc;
00990 static VLC v2_mb_type_vlc;
00991 static VLC v2_mv_vlc;
00992 static VLC v1_intra_cbpc_vlc;
00993 static VLC v1_inter_cbpc_vlc;
00994 VLC ff_inter_intra_vlc;
00995 
00996 /* This table is practically identical to the one from h263
00997  * except that it is inverted. */
00998 static av_cold void init_h263_dc_for_msmpeg4(void)
00999 {
01000         int level, uni_code, uni_len;
01001 
01002         for(level=-256; level<256; level++){
01003             int size, v, l;
01004             /* find number of bits */
01005             size = 0;
01006             v = abs(level);
01007             while (v) {
01008                 v >>= 1;
01009                     size++;
01010             }
01011 
01012             if (level < 0)
01013                 l= (-level) ^ ((1 << size) - 1);
01014             else
01015                 l= level;
01016 
01017             /* luminance h263 */
01018             uni_code= DCtab_lum[size][0];
01019             uni_len = DCtab_lum[size][1];
01020             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
01021 
01022             if (size > 0) {
01023                 uni_code<<=size; uni_code|=l;
01024                 uni_len+=size;
01025                 if (size > 8){
01026                     uni_code<<=1; uni_code|=1;
01027                     uni_len++;
01028                 }
01029             }
01030             v2_dc_lum_table[level+256][0]= uni_code;
01031             v2_dc_lum_table[level+256][1]= uni_len;
01032 
01033             /* chrominance h263 */
01034             uni_code= DCtab_chrom[size][0];
01035             uni_len = DCtab_chrom[size][1];
01036             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
01037 
01038             if (size > 0) {
01039                 uni_code<<=size; uni_code|=l;
01040                 uni_len+=size;
01041                 if (size > 8){
01042                     uni_code<<=1; uni_code|=1;
01043                     uni_len++;
01044                 }
01045             }
01046             v2_dc_chroma_table[level+256][0]= uni_code;
01047             v2_dc_chroma_table[level+256][1]= uni_len;
01048 
01049         }
01050 }
01051 
01052 /* init all vlc decoding tables */
01053 av_cold int ff_msmpeg4_decode_init(MpegEncContext *s)
01054 {
01055     static int done = 0;
01056     int i;
01057     MVTable *mv;
01058 
01059     common_init(s);
01060 
01061     if (!done) {
01062         done = 1;
01063 
01064         for(i=0;i<NB_RL_TABLES;i++) {
01065             init_rl(&rl_table[i], static_rl_table_store[i]);
01066         }
01067         INIT_VLC_RL(rl_table[0], 642);
01068         INIT_VLC_RL(rl_table[1], 1104);
01069         INIT_VLC_RL(rl_table[2], 554);
01070         INIT_VLC_RL(rl_table[3], 940);
01071         INIT_VLC_RL(rl_table[4], 962);
01072         INIT_VLC_RL(rl_table[5], 554);
01073         for(i=0;i<2;i++) {
01074             mv = &mv_tables[i];
01075             init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
01076                      mv->table_mv_bits, 1, 1,
01077                      mv->table_mv_code, 2, 2, 1);
01078         }
01079 
01080         init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
01081                  &ff_table0_dc_lum[0][1], 8, 4,
01082                  &ff_table0_dc_lum[0][0], 8, 4, 1);
01083         init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
01084                  &ff_table0_dc_chroma[0][1], 8, 4,
01085                  &ff_table0_dc_chroma[0][0], 8, 4, 1);
01086         init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
01087                  &ff_table1_dc_lum[0][1], 8, 4,
01088                  &ff_table1_dc_lum[0][0], 8, 4, 1);
01089         init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
01090                  &ff_table1_dc_chroma[0][1], 8, 4,
01091                  &ff_table1_dc_chroma[0][0], 8, 4, 1);
01092 
01093         init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
01094                  &v2_dc_lum_table[0][1], 8, 4,
01095                  &v2_dc_lum_table[0][0], 8, 4, 1);
01096         init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
01097                  &v2_dc_chroma_table[0][1], 8, 4,
01098                  &v2_dc_chroma_table[0][0], 8, 4, 1);
01099 
01100         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
01101                  &cbpy_tab[0][1], 2, 1,
01102                  &cbpy_tab[0][0], 2, 1, 1);
01103         init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
01104                  &v2_intra_cbpc[0][1], 2, 1,
01105                  &v2_intra_cbpc[0][0], 2, 1, 1);
01106         init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
01107                  &v2_mb_type[0][1], 2, 1,
01108                  &v2_mb_type[0][0], 2, 1, 1);
01109         init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
01110                  &mvtab[0][1], 2, 1,
01111                  &mvtab[0][0], 2, 1, 1);
01112 
01113         for(i=0; i<4; i++){
01114             init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
01115                      &wmv2_inter_table[i][0][1], 8, 4,
01116                      &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
01117         }
01118 
01119         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
01120                  &ff_msmp4_mb_i_table[0][1], 4, 2,
01121                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
01122 
01123         init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
01124                  intra_MCBPC_bits, 1, 1,
01125                  intra_MCBPC_code, 1, 1, 1);
01126         init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
01127                  inter_MCBPC_bits, 1, 1,
01128                  inter_MCBPC_code, 1, 1, 1);
01129 
01130         init_vlc(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
01131                  &table_inter_intra[0][1], 2, 1,
01132                  &table_inter_intra[0][0], 2, 1, 1);
01133     }
01134 
01135     switch(s->msmpeg4_version){
01136     case 1:
01137     case 2:
01138         s->decode_mb= msmpeg4v12_decode_mb;
01139         break;
01140     case 3:
01141     case 4:
01142         s->decode_mb= msmpeg4v34_decode_mb;
01143         break;
01144     case 5:
01145         if (CONFIG_WMV2_DECODER)
01146             s->decode_mb= ff_wmv2_decode_mb;
01147     case 6:
01148         //FIXME + TODO VC1 decode mb
01149         break;
01150     }
01151 
01152     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
01153 
01154     return 0;
01155 }
01156 
01157 int msmpeg4_decode_picture_header(MpegEncContext * s)
01158 {
01159     int code;
01160 
01161 #if 0
01162 {
01163 int i;
01164 for(i=0; i<s->gb.size_in_bits; i++)
01165     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
01166 //    get_bits1(&s->gb);
01167 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
01168 return -1;
01169 }
01170 #endif
01171 
01172     if(s->msmpeg4_version==1){
01173         int start_code, num;
01174         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
01175         if(start_code!=0x00000100){
01176             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
01177             return -1;
01178         }
01179 
01180         num= get_bits(&s->gb, 5); // frame number */
01181     }
01182 
01183     s->pict_type = get_bits(&s->gb, 2) + 1;
01184     if (s->pict_type != FF_I_TYPE &&
01185         s->pict_type != FF_P_TYPE){
01186         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
01187         return -1;
01188     }
01189 #if 0
01190 {
01191     static int had_i=0;
01192     if(s->pict_type == FF_I_TYPE) had_i=1;
01193     if(!had_i) return -1;
01194 }
01195 #endif
01196     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
01197     if(s->qscale==0){
01198         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
01199         return -1;
01200     }
01201 
01202     if (s->pict_type == FF_I_TYPE) {
01203         code = get_bits(&s->gb, 5);
01204         if(s->msmpeg4_version==1){
01205             if(code==0 || code>s->mb_height){
01206                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
01207                 return -1;
01208             }
01209 
01210             s->slice_height = code;
01211         }else{
01212             /* 0x17: one slice, 0x18: two slices, ... */
01213             if (code < 0x17){
01214                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
01215                 return -1;
01216             }
01217 
01218             s->slice_height = s->mb_height / (code - 0x16);
01219         }
01220 
01221         switch(s->msmpeg4_version){
01222         case 1:
01223         case 2:
01224             s->rl_chroma_table_index = 2;
01225             s->rl_table_index = 2;
01226 
01227             s->dc_table_index = 0; //not used
01228             break;
01229         case 3:
01230             s->rl_chroma_table_index = decode012(&s->gb);
01231             s->rl_table_index = decode012(&s->gb);
01232 
01233             s->dc_table_index = get_bits1(&s->gb);
01234             break;
01235         case 4:
01236             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
01237 
01238             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
01239             else                           s->per_mb_rl_table= 0;
01240 
01241             if(!s->per_mb_rl_table){
01242                 s->rl_chroma_table_index = decode012(&s->gb);
01243                 s->rl_table_index = decode012(&s->gb);
01244             }
01245 
01246             s->dc_table_index = get_bits1(&s->gb);
01247             s->inter_intra_pred= 0;
01248             break;
01249         }
01250         s->no_rounding = 1;
01251         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
01252             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
01253                 s->qscale,
01254                 s->rl_chroma_table_index,
01255                 s->rl_table_index,
01256                 s->dc_table_index,
01257                 s->per_mb_rl_table,
01258                 s->slice_height);
01259     } else {
01260         switch(s->msmpeg4_version){
01261         case 1:
01262         case 2:
01263             if(s->msmpeg4_version==1)
01264                 s->use_skip_mb_code = 1;
01265             else
01266                 s->use_skip_mb_code = get_bits1(&s->gb);
01267             s->rl_table_index = 2;
01268             s->rl_chroma_table_index = s->rl_table_index;
01269             s->dc_table_index = 0; //not used
01270             s->mv_table_index = 0;
01271             break;
01272         case 3:
01273             s->use_skip_mb_code = get_bits1(&s->gb);
01274             s->rl_table_index = decode012(&s->gb);
01275             s->rl_chroma_table_index = s->rl_table_index;
01276 
01277             s->dc_table_index = get_bits1(&s->gb);
01278 
01279             s->mv_table_index = get_bits1(&s->gb);
01280             break;
01281         case 4:
01282             s->use_skip_mb_code = get_bits1(&s->gb);
01283 
01284             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
01285             else                           s->per_mb_rl_table= 0;
01286 
01287             if(!s->per_mb_rl_table){
01288                 s->rl_table_index = decode012(&s->gb);
01289                 s->rl_chroma_table_index = s->rl_table_index;
01290             }
01291 
01292             s->dc_table_index = get_bits1(&s->gb);
01293 
01294             s->mv_table_index = get_bits1(&s->gb);
01295             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
01296             break;
01297         }
01298 
01299         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
01300             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
01301                 s->use_skip_mb_code,
01302                 s->rl_table_index,
01303                 s->rl_chroma_table_index,
01304                 s->dc_table_index,
01305                 s->mv_table_index,
01306                 s->per_mb_rl_table,
01307                 s->qscale);
01308 
01309         if(s->flipflop_rounding){
01310             s->no_rounding ^= 1;
01311         }else{
01312             s->no_rounding = 0;
01313         }
01314     }
01315 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
01316 
01317     s->esc3_level_length= 0;
01318     s->esc3_run_length= 0;
01319 
01320 #ifdef DEBUG
01321     av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
01322 #endif
01323     return 0;
01324 }
01325 
01326 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
01327 {
01328     int left= buf_size*8 - get_bits_count(&s->gb);
01329     int length= s->msmpeg4_version>=3 ? 17 : 16;
01330     /* the alt_bitstream reader could read over the end so we need to check it */
01331     if(left>=length && left<length+8)
01332     {
01333         int fps;
01334 
01335         fps= get_bits(&s->gb, 5);
01336         s->bit_rate= get_bits(&s->gb, 11)*1024;
01337         if(s->msmpeg4_version>=3)
01338             s->flipflop_rounding= get_bits1(&s->gb);
01339         else
01340             s->flipflop_rounding= 0;
01341 
01342 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
01343     }
01344     else if(left<length+8)
01345     {
01346         s->flipflop_rounding= 0;
01347         if(s->msmpeg4_version != 2)
01348             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
01349     }
01350     else
01351     {
01352         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
01353     }
01354 
01355     return 0;
01356 }
01357 
01358 static inline void msmpeg4_memsetw(short *tab, int val, int n)
01359 {
01360     int i;
01361     for(i=0;i<n;i++)
01362         tab[i] = val;
01363 }
01364 
01365 #if CONFIG_ENCODERS
01366 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
01367 {
01368     int range, bit_size, sign, code, bits;
01369 
01370     if (val == 0) {
01371         /* zero vector */
01372         code = 0;
01373         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
01374     } else {
01375         bit_size = s->f_code - 1;
01376         range = 1 << bit_size;
01377         if (val <= -64)
01378             val += 64;
01379         else if (val >= 64)
01380             val -= 64;
01381 
01382         if (val >= 0) {
01383             sign = 0;
01384         } else {
01385             val = -val;
01386             sign = 1;
01387         }
01388         val--;
01389         code = (val >> bit_size) + 1;
01390         bits = val & (range - 1);
01391 
01392         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
01393         if (bit_size > 0) {
01394             put_bits(&s->pb, bit_size, bits);
01395         }
01396     }
01397 }
01398 #endif
01399 
01400 /* This is identical to h263 except that its range is multiplied by 2. */
01401 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
01402 {
01403     int code, val, sign, shift;
01404 
01405     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
01406 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
01407     if (code < 0)
01408         return 0xffff;
01409 
01410     if (code == 0)
01411         return pred;
01412     sign = get_bits1(&s->gb);
01413     shift = f_code - 1;
01414     val = code;
01415     if (shift) {
01416         val = (val - 1) << shift;
01417         val |= get_bits(&s->gb, shift);
01418         val++;
01419     }
01420     if (sign)
01421         val = -val;
01422 
01423     val += pred;
01424     if (val <= -64)
01425         val += 64;
01426     else if (val >= 64)
01427         val -= 64;
01428 
01429     return val;
01430 }
01431 
01432 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
01433 {
01434     int cbp, code, i;
01435 
01436     if (s->pict_type == FF_P_TYPE) {
01437         if (s->use_skip_mb_code) {
01438             if (get_bits1(&s->gb)) {
01439                 /* skip mb */
01440                 s->mb_intra = 0;
01441                 for(i=0;i<6;i++)
01442                     s->block_last_index[i] = -1;
01443                 s->mv_dir = MV_DIR_FORWARD;
01444                 s->mv_type = MV_TYPE_16X16;
01445                 s->mv[0][0][0] = 0;
01446                 s->mv[0][0][1] = 0;
01447                 s->mb_skipped = 1;
01448                 return 0;
01449             }
01450         }
01451 
01452         if(s->msmpeg4_version==2)
01453             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
01454         else
01455             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
01456         if(code<0 || code>7){
01457             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
01458             return -1;
01459         }
01460 
01461         s->mb_intra = code >>2;
01462 
01463         cbp = code & 0x3;
01464     } else {
01465         s->mb_intra = 1;
01466         if(s->msmpeg4_version==2)
01467             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
01468         else
01469             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
01470         if(cbp<0 || cbp>3){
01471             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
01472             return -1;
01473         }
01474     }
01475 
01476     if (!s->mb_intra) {
01477         int mx, my, cbpy;
01478 
01479         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
01480         if(cbpy<0){
01481             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
01482             return -1;
01483         }
01484 
01485         cbp|= cbpy<<2;
01486         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
01487 
01488         h263_pred_motion(s, 0, 0, &mx, &my);
01489         mx= msmpeg4v2_decode_motion(s, mx, 1);
01490         my= msmpeg4v2_decode_motion(s, my, 1);
01491 
01492         s->mv_dir = MV_DIR_FORWARD;
01493         s->mv_type = MV_TYPE_16X16;
01494         s->mv[0][0][0] = mx;
01495         s->mv[0][0][1] = my;
01496     } else {
01497         if(s->msmpeg4_version==2){
01498             s->ac_pred = get_bits1(&s->gb);
01499             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
01500         } else{
01501             s->ac_pred = 0;
01502             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
01503             if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
01504         }
01505     }
01506 
01507     s->dsp.clear_blocks(s->block[0]);
01508     for (i = 0; i < 6; i++) {
01509         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
01510         {
01511              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
01512              return -1;
01513         }
01514     }
01515     return 0;
01516 }
01517 
01518 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
01519 {
01520     int cbp, code, i;
01521     uint8_t *coded_val;
01522     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
01523 
01524     if (s->pict_type == FF_P_TYPE) {
01525         if (s->use_skip_mb_code) {
01526             if (get_bits1(&s->gb)) {
01527                 /* skip mb */
01528                 s->mb_intra = 0;
01529                 for(i=0;i<6;i++)
01530                     s->block_last_index[i] = -1;
01531                 s->mv_dir = MV_DIR_FORWARD;
01532                 s->mv_type = MV_TYPE_16X16;
01533                 s->mv[0][0][0] = 0;
01534                 s->mv[0][0][1] = 0;
01535                 s->mb_skipped = 1;
01536                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
01537 
01538                 return 0;
01539             }
01540         }
01541 
01542         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
01543         if (code < 0)
01544             return -1;
01545         //s->mb_intra = (code & 0x40) ? 0 : 1;
01546         s->mb_intra = (~code & 0x40) >> 6;
01547 
01548         cbp = code & 0x3f;
01549     } else {
01550         s->mb_intra = 1;
01551         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
01552         if (code < 0)
01553             return -1;
01554         /* predict coded block pattern */
01555         cbp = 0;
01556         for(i=0;i<6;i++) {
01557             int val = ((code >> (5 - i)) & 1);
01558             if (i < 4) {
01559                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
01560                 val = val ^ pred;
01561                 *coded_val = val;
01562             }
01563             cbp |= val << (5 - i);
01564         }
01565     }
01566 
01567     if (!s->mb_intra) {
01568         int mx, my;
01569 //printf("P at %d %d\n", s->mb_x, s->mb_y);
01570         if(s->per_mb_rl_table && cbp){
01571             s->rl_table_index = decode012(&s->gb);
01572             s->rl_chroma_table_index = s->rl_table_index;
01573         }
01574         h263_pred_motion(s, 0, 0, &mx, &my);
01575         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
01576             return -1;
01577         s->mv_dir = MV_DIR_FORWARD;
01578         s->mv_type = MV_TYPE_16X16;
01579         s->mv[0][0][0] = mx;
01580         s->mv[0][0][1] = my;
01581         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
01582     } else {
01583 //printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
01584         s->ac_pred = get_bits1(&s->gb);
01585         *mb_type_ptr = MB_TYPE_INTRA;
01586         if(s->inter_intra_pred){
01587             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
01588 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
01589         }
01590         if(s->per_mb_rl_table && cbp){
01591             s->rl_table_index = decode012(&s->gb);
01592             s->rl_chroma_table_index = s->rl_table_index;
01593         }
01594     }
01595 
01596     s->dsp.clear_blocks(s->block[0]);
01597     for (i = 0; i < 6; i++) {
01598         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
01599         {
01600             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
01601             return -1;
01602         }
01603     }
01604 
01605     return 0;
01606 }
01607 //#define ERROR_DETAILS
01608 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
01609                               int n, int coded, const uint8_t *scan_table)
01610 {
01611     int level, i, last, run, run_diff;
01612     int av_uninit(dc_pred_dir);
01613     RLTable *rl;
01614     RL_VLC_ELEM *rl_vlc;
01615     int qmul, qadd;
01616 
01617     if (s->mb_intra) {
01618         qmul=1;
01619         qadd=0;
01620 
01621         /* DC coef */
01622         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
01623 
01624         if (level < 0){
01625             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
01626             if(s->inter_intra_pred) level=0;
01627             else                    return -1;
01628         }
01629         if (n < 4) {
01630             rl = &rl_table[s->rl_table_index];
01631             if(level > 256*s->y_dc_scale){
01632                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
01633                 if(!s->inter_intra_pred) return -1;
01634             }
01635         } else {
01636             rl = &rl_table[3 + s->rl_chroma_table_index];
01637             if(level > 256*s->c_dc_scale){
01638                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
01639                 if(!s->inter_intra_pred) return -1;
01640             }
01641         }
01642         block[0] = level;
01643 
01644         run_diff = s->msmpeg4_version >= 4;
01645         i = 0;
01646         if (!coded) {
01647             goto not_coded;
01648         }
01649         if (s->ac_pred) {
01650             if (dc_pred_dir == 0)
01651                 scan_table = s->intra_v_scantable.permutated; /* left */
01652             else
01653                 scan_table = s->intra_h_scantable.permutated; /* top */
01654         } else {
01655             scan_table = s->intra_scantable.permutated;
01656         }
01657         rl_vlc= rl->rl_vlc[0];
01658     } else {
01659         qmul = s->qscale << 1;
01660         qadd = (s->qscale - 1) | 1;
01661         i = -1;
01662         rl = &rl_table[3 + s->rl_table_index];
01663 
01664         if(s->msmpeg4_version==2)
01665             run_diff = 0;
01666         else
01667             run_diff = 1;
01668 
01669         if (!coded) {
01670             s->block_last_index[n] = i;
01671             return 0;
01672         }
01673         if(!scan_table)
01674             scan_table = s->inter_scantable.permutated;
01675         rl_vlc= rl->rl_vlc[s->qscale];
01676     }
01677   {
01678     OPEN_READER(re, &s->gb);
01679     for(;;) {
01680         UPDATE_CACHE(re, &s->gb);
01681         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
01682         if (level==0) {
01683             int cache;
01684             cache= GET_CACHE(re, &s->gb);
01685             /* escape */
01686             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
01687                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
01688                     /* third escape */
01689                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
01690                     UPDATE_CACHE(re, &s->gb);
01691                     if(s->msmpeg4_version<=3){
01692                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
01693                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
01694                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
01695                         SKIP_COUNTER(re, &s->gb, 1+6+8);
01696                     }else{
01697                         int sign;
01698                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
01699                         if(!s->esc3_level_length){
01700                             int ll;
01701                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
01702                             if(s->qscale<8){
01703                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
01704                                 if(ll==0){
01705                                     if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
01706                                     SKIP_BITS(re, &s->gb, 1);
01707                                     ll=8;
01708                                 }
01709                             }else{
01710                                 ll=2;
01711                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
01712                                     ll++;
01713                                     SKIP_BITS(re, &s->gb, 1);
01714                                 }
01715                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
01716                             }
01717 
01718                             s->esc3_level_length= ll;
01719                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
01720 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
01721                             UPDATE_CACHE(re, &s->gb);
01722                         }
01723                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
01724                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
01725 
01726                         sign=  SHOW_UBITS(re, &s->gb, 1);
01727                         SKIP_BITS(re, &s->gb, 1);
01728 
01729                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
01730                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
01731                         if(sign) level= -level;
01732                     }
01733 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
01734 #if 0 // waste of time / this will detect very few errors
01735                     {
01736                         const int abs_level= FFABS(level);
01737                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
01738                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
01739                             if(abs_level <= rl->max_level[last][run]){
01740                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
01741                                 return DECODING_AC_LOST;
01742                             }
01743                             if(abs_level <= rl->max_level[last][run]*2){
01744                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
01745                                 return DECODING_AC_LOST;
01746                             }
01747                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
01748                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
01749                                 return DECODING_AC_LOST;
01750                             }
01751                         }
01752                     }
01753 #endif
01754                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
01755                     if (level>0) level= level * qmul + qadd;
01756                     else         level= level * qmul - qadd;
01757 #if 0 // waste of time too :(
01758                     if(level>2048 || level<-2048){
01759                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
01760                         return DECODING_AC_LOST;
01761                     }
01762 #endif
01763                     i+= run + 1;
01764                     if(last) i+=192;
01765 #ifdef ERROR_DETAILS
01766                 if(run==66)
01767                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
01768                 else if((i>62 && i<192) || i>192+63)
01769                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
01770 #endif
01771                 } else {
01772                     /* second escape */
01773 #if MIN_CACHE_BITS < 23
01774                     LAST_SKIP_BITS(re, &s->gb, 2);
01775                     UPDATE_CACHE(re, &s->gb);
01776 #else
01777                     SKIP_BITS(re, &s->gb, 2);
01778 #endif
01779                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01780                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
01781                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01782                     LAST_SKIP_BITS(re, &s->gb, 1);
01783 #ifdef ERROR_DETAILS
01784                 if(run==66)
01785                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
01786                 else if((i>62 && i<192) || i>192+63)
01787                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
01788 #endif
01789                 }
01790             } else {
01791                 /* first escape */
01792 #if MIN_CACHE_BITS < 22
01793                 LAST_SKIP_BITS(re, &s->gb, 1);
01794                 UPDATE_CACHE(re, &s->gb);
01795 #else
01796                 SKIP_BITS(re, &s->gb, 1);
01797 #endif
01798                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01799                 i+= run;
01800                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
01801                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01802                 LAST_SKIP_BITS(re, &s->gb, 1);
01803 #ifdef ERROR_DETAILS
01804                 if(run==66)
01805                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
01806                 else if((i>62 && i<192) || i>192+63)
01807                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
01808 #endif
01809             }
01810         } else {
01811             i+= run;
01812             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01813             LAST_SKIP_BITS(re, &s->gb, 1);
01814 #ifdef ERROR_DETAILS
01815                 if(run==66)
01816                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
01817                 else if((i>62 && i<192) || i>192+63)
01818                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
01819 #endif
01820         }
01821         if (i > 62){
01822             i-= 192;
01823             if(i&(~63)){
01824                 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
01825                 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
01826                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
01827                     break;
01828                 }else{
01829                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
01830                     return -1;
01831                 }
01832             }
01833 
01834             block[scan_table[i]] = level;
01835             break;
01836         }
01837 
01838         block[scan_table[i]] = level;
01839     }
01840     CLOSE_READER(re, &s->gb);
01841   }
01842  not_coded:
01843     if (s->mb_intra) {
01844         mpeg4_pred_ac(s, block, n, dc_pred_dir);
01845         if (s->ac_pred) {
01846             i = 63; /* XXX: not optimal */
01847         }
01848     }
01849     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
01850     s->block_last_index[n] = i;
01851 
01852     return 0;
01853 }
01854 
01855 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
01856 {
01857     int level, pred;
01858 
01859     if(s->msmpeg4_version<=2){
01860         if (n < 4) {
01861             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
01862         } else {
01863             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
01864         }
01865         if (level < 0)
01866             return -1;
01867         level-=256;
01868     }else{  //FIXME optimize use unified tables & index
01869         if (n < 4) {
01870             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01871         } else {
01872             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01873         }
01874         if (level < 0){
01875             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
01876             return -1;
01877         }
01878 
01879         if (level == DC_MAX) {
01880             level = get_bits(&s->gb, 8);
01881             if (get_bits1(&s->gb))
01882                 level = -level;
01883         } else if (level != 0) {
01884             if (get_bits1(&s->gb))
01885                 level = -level;
01886         }
01887     }
01888 
01889     if(s->msmpeg4_version==1){
01890         int32_t *dc_val;
01891         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
01892         level += pred;
01893 
01894         /* update predictor */
01895         *dc_val= level;
01896     }else{
01897         int16_t *dc_val;
01898         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
01899         level += pred;
01900 
01901         /* update predictor */
01902         if (n < 4) {
01903             *dc_val = level * s->y_dc_scale;
01904         } else {
01905             *dc_val = level * s->c_dc_scale;
01906         }
01907     }
01908 
01909     return level;
01910 }
01911 
01912 int ff_msmpeg4_decode_motion(MpegEncContext * s,
01913                                  int *mx_ptr, int *my_ptr)
01914 {
01915     MVTable *mv;
01916     int code, mx, my;
01917 
01918     mv = &mv_tables[s->mv_table_index];
01919 
01920     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
01921     if (code < 0){
01922         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
01923         return -1;
01924     }
01925     if (code == mv->n) {
01926 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
01927         mx = get_bits(&s->gb, 6);
01928         my = get_bits(&s->gb, 6);
01929     } else {
01930         mx = mv->table_mvx[code];
01931         my = mv->table_mvy[code];
01932     }
01933 
01934     mx += *mx_ptr - 32;
01935     my += *my_ptr - 32;
01936     /* WARNING : they do not do exactly modulo encoding */
01937     if (mx <= -64)
01938         mx += 64;
01939     else if (mx >= 64)
01940         mx -= 64;
01941 
01942     if (my <= -64)
01943         my += 64;
01944     else if (my >= 64)
01945         my -= 64;
01946     *mx_ptr = mx;
01947     *my_ptr = my;
01948     return 0;
01949 }

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