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