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==FF_I_TYPE){
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==FF_P_TYPE) 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==FF_I_TYPE)
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==FF_P_TYPE);
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 == FF_I_TYPE) {
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 #if 0
00621         if (coded_cbp)
00622             printf("cbp=%x %x\n", cbp, coded_cbp);
00623 #endif
00624 
00625         if(s->msmpeg4_version<=2){
00626             if (s->pict_type == FF_I_TYPE) {
00627                 put_bits(&s->pb,
00628                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
00629             } else {
00630                 if (s->use_skip_mb_code)
00631                     put_bits(&s->pb, 1, 0);     /* mb coded */
00632                 put_bits(&s->pb,
00633                          v2_mb_type[(cbp&3) + 4][1],
00634                          v2_mb_type[(cbp&3) + 4][0]);
00635             }
00636             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
00637             put_bits(&s->pb,
00638                      ff_h263_cbpy_tab[cbp>>2][1],
00639                      ff_h263_cbpy_tab[cbp>>2][0]);
00640         }else{
00641             if (s->pict_type == FF_I_TYPE) {
00642                 put_bits(&s->pb,
00643                          ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
00644             } else {
00645                 if (s->use_skip_mb_code)
00646                     put_bits(&s->pb, 1, 0);     /* mb coded */
00647                 put_bits(&s->pb,
00648                          table_mb_non_intra[cbp][1],
00649                          table_mb_non_intra[cbp][0]);
00650             }
00651             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
00652             if(s->inter_intra_pred){
00653                 s->h263_aic_dir=0;
00654                 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
00655             }
00656         }
00657         s->misc_bits += get_bits_diff(s);
00658 
00659         for (i = 0; i < 6; i++) {
00660             ff_msmpeg4_encode_block(s, block[i], i);
00661         }
00662         s->i_tex_bits += get_bits_diff(s);
00663         s->i_count++;
00664     }
00665 }
00666 
00667 #endif //CONFIG_ENCODERS
00668 
00669 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
00670                                     int32_t **dc_val_ptr)
00671 {
00672     int i;
00673 
00674     if (n < 4) {
00675         i= 0;
00676     } else {
00677         i= n-3;
00678     }
00679 
00680     *dc_val_ptr= &s->last_dc[i];
00681     return s->last_dc[i];
00682 }
00683 
00684 static int get_dc(uint8_t *src, int stride, int scale)
00685 {
00686     int y;
00687     int sum=0;
00688     for(y=0; y<8; y++){
00689         int x;
00690         for(x=0; x<8; x++){
00691             sum+=src[x + y*stride];
00692         }
00693     }
00694     return FASTDIV((sum + (scale>>1)), scale);
00695 }
00696 
00697 /* dir = 0: left, dir = 1: top prediction */
00698 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
00699                              int16_t **dc_val_ptr, int *dir_ptr)
00700 {
00701     int a, b, c, wrap, pred, scale;
00702     int16_t *dc_val;
00703 
00704     /* find prediction */
00705     if (n < 4) {
00706         scale = s->y_dc_scale;
00707     } else {
00708         scale = s->c_dc_scale;
00709     }
00710 
00711     wrap = s->block_wrap[n];
00712     dc_val= s->dc_val[0] + s->block_index[n];
00713 
00714     /* B C
00715      * A X
00716      */
00717     a = dc_val[ - 1];
00718     b = dc_val[ - 1 - wrap];
00719     c = dc_val[ - wrap];
00720 
00721     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
00722         b=c=1024;
00723     }
00724 
00725     /* XXX: the following solution consumes divisions, but it does not
00726        necessitate to modify mpegvideo.c. The problem comes from the
00727        fact they decided to store the quantized DC (which would lead
00728        to problems if Q could vary !) */
00729 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
00730     __asm__ volatile(
00731         "movl %3, %%eax         \n\t"
00732         "shrl $1, %%eax         \n\t"
00733         "addl %%eax, %2         \n\t"
00734         "addl %%eax, %1         \n\t"
00735         "addl %0, %%eax         \n\t"
00736         "mull %4                \n\t"
00737         "movl %%edx, %0         \n\t"
00738         "movl %1, %%eax         \n\t"
00739         "mull %4                \n\t"
00740         "movl %%edx, %1         \n\t"
00741         "movl %2, %%eax         \n\t"
00742         "mull %4                \n\t"
00743         "movl %%edx, %2         \n\t"
00744         : "+b" (a), "+c" (b), "+D" (c)
00745         : "g" (scale), "S" (ff_inverse[scale])
00746         : "%eax", "%edx"
00747     );
00748 #else
00749     /* #elif ARCH_ALPHA */
00750     /* Divisions are extremely costly on Alpha; optimize the most
00751        common case. But they are costly everywhere...
00752      */
00753     if (scale == 8) {
00754         a = (a + (8 >> 1)) / 8;
00755         b = (b + (8 >> 1)) / 8;
00756         c = (c + (8 >> 1)) / 8;
00757     } else {
00758         a = FASTDIV((a + (scale >> 1)), scale);
00759         b = FASTDIV((b + (scale >> 1)), scale);
00760         c = FASTDIV((c + (scale >> 1)), scale);
00761     }
00762 #endif
00763     /* XXX: WARNING: they did not choose the same test as MPEG4. This
00764        is very important ! */
00765     if(s->msmpeg4_version>3){
00766         if(s->inter_intra_pred){
00767             uint8_t *dest;
00768             int wrap;
00769 
00770             if(n==1){
00771                 pred=a;
00772                 *dir_ptr = 0;
00773             }else if(n==2){
00774                 pred=c;
00775                 *dir_ptr = 1;
00776             }else if(n==3){
00777                 if (abs(a - b) < abs(b - c)) {
00778                     pred = c;
00779                     *dir_ptr = 1;
00780                 } else {
00781                     pred = a;
00782                     *dir_ptr = 0;
00783                 }
00784             }else{
00785                 if(n<4){
00786                     wrap= s->linesize;
00787                     dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
00788                 }else{
00789                     wrap= s->uvlinesize;
00790                     dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
00791                 }
00792                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
00793                 else           a= get_dc(dest-8, wrap, scale*8);
00794                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
00795                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
00796 
00797                 if (s->h263_aic_dir==0) {
00798                     pred= a;
00799                     *dir_ptr = 0;
00800                 }else if (s->h263_aic_dir==1) {
00801                     if(n==0){
00802                         pred= c;
00803                         *dir_ptr = 1;
00804                     }else{
00805                         pred= a;
00806                         *dir_ptr = 0;
00807                     }
00808                 }else if (s->h263_aic_dir==2) {
00809                     if(n==0){
00810                         pred= a;
00811                         *dir_ptr = 0;
00812                     }else{
00813                         pred= c;
00814                         *dir_ptr = 1;
00815                     }
00816                 } else {
00817                     pred= c;
00818                     *dir_ptr = 1;
00819                 }
00820             }
00821         }else{
00822             if (abs(a - b) < abs(b - c)) {
00823                 pred = c;
00824                 *dir_ptr = 1;
00825             } else {
00826                 pred = a;
00827                 *dir_ptr = 0;
00828             }
00829         }
00830     }else{
00831         if (abs(a - b) <= abs(b - c)) {
00832             pred = c;
00833             *dir_ptr = 1;
00834         } else {
00835             pred = a;
00836             *dir_ptr = 0;
00837         }
00838     }
00839 
00840     /* update predictor */
00841     *dc_val_ptr = &dc_val[0];
00842     return pred;
00843 }
00844 
00845 #define DC_MAX 119
00846 
00847 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
00848 {
00849     int sign, code;
00850     int pred, extquant;
00851     int extrabits = 0;
00852 
00853     if(s->msmpeg4_version==1){
00854         int32_t *dc_val;
00855         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
00856 
00857         /* update predictor */
00858         *dc_val= level;
00859     }else{
00860         int16_t *dc_val;
00861         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
00862 
00863         /* update predictor */
00864         if (n < 4) {
00865             *dc_val = level * s->y_dc_scale;
00866         } else {
00867             *dc_val = level * s->c_dc_scale;
00868         }
00869     }
00870 
00871     /* do the prediction */
00872     level -= pred;
00873 
00874     if(s->msmpeg4_version<=2){
00875         if (n < 4) {
00876             put_bits(&s->pb,
00877                      v2_dc_lum_table[level+256][1],
00878                      v2_dc_lum_table[level+256][0]);
00879         }else{
00880             put_bits(&s->pb,
00881                      v2_dc_chroma_table[level+256][1],
00882                      v2_dc_chroma_table[level+256][0]);
00883         }
00884     }else{
00885         sign = 0;
00886         if (level < 0) {
00887             level = -level;
00888             sign = 1;
00889         }
00890         code = level;
00891         if (code > DC_MAX)
00892             code = DC_MAX;
00893         else if( s->msmpeg4_version>=6 ) {
00894             if( s->qscale == 1 ) {
00895                 extquant = (level + 3) & 0x3;
00896                 code  = ((level+3)>>2);
00897             } else if( s->qscale == 2 ) {
00898                 extquant = (level + 1) & 0x1;
00899                 code  = ((level+1)>>1);
00900             }
00901         }
00902 
00903         if (s->dc_table_index == 0) {
00904             if (n < 4) {
00905                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
00906             } else {
00907                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
00908             }
00909         } else {
00910             if (n < 4) {
00911                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
00912             } else {
00913                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
00914             }
00915         }
00916 
00917         if(s->msmpeg4_version>=6 && s->qscale<=2)
00918             extrabits = 3 - s->qscale;
00919 
00920         if (code == DC_MAX)
00921             put_bits(&s->pb, 8 + extrabits, level);
00922         else if(extrabits > 0)//== VC1 && s->qscale<=2
00923             put_bits(&s->pb, extrabits, extquant);
00924 
00925         if (level != 0) {
00926             put_bits(&s->pb, 1, sign);
00927         }
00928     }
00929 }
00930 
00931 /* Encoding of a block. Very similar to MPEG4 except for a different
00932    escape coding (same as H263) and more vlc tables.
00933  */
00934 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
00935 {
00936     int level, run, last, i, j, last_index;
00937     int last_non_zero, sign, slevel;
00938     int code, run_diff, dc_pred_dir;
00939     const RLTable *rl;
00940     const uint8_t *scantable;
00941 
00942     if (s->mb_intra) {
00943         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
00944         i = 1;
00945         if (n < 4) {
00946             rl = &rl_table[s->rl_table_index];
00947         } else {
00948             rl = &rl_table[3 + s->rl_chroma_table_index];
00949         }
00950         run_diff = s->msmpeg4_version>=4;
00951         scantable= s->intra_scantable.permutated;
00952     } else {
00953         i = 0;
00954         rl = &rl_table[3 + s->rl_table_index];
00955         if(s->msmpeg4_version<=2)
00956             run_diff = 0;
00957         else
00958             run_diff = 1;
00959         scantable= s->inter_scantable.permutated;
00960     }
00961 
00962     /* recalculate block_last_index for M$ wmv1 */
00963     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
00964         for(last_index=63; last_index>=0; last_index--){
00965             if(block[scantable[last_index]]) break;
00966         }
00967         s->block_last_index[n]= last_index;
00968     }else
00969         last_index = s->block_last_index[n];
00970     /* AC coefs */
00971     last_non_zero = i - 1;
00972     for (; i <= last_index; i++) {
00973         j = scantable[i];
00974         level = block[j];
00975         if (level) {
00976             run = i - last_non_zero - 1;
00977             last = (i == last_index);
00978             sign = 0;
00979             slevel = level;
00980             if (level < 0) {
00981                 sign = 1;
00982                 level = -level;
00983             }
00984 
00985             if(level<=MAX_LEVEL && run<=MAX_RUN){
00986                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
00987             }
00988 #if 0
00989 else
00990     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
00991 #endif
00992             code = get_rl_index(rl, last, run, level);
00993             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
00994             if (code == rl->n) {
00995                 int level1, run1;
00996 
00997                 level1 = level - rl->max_level[last][run];
00998                 if (level1 < 1)
00999                     goto esc2;
01000                 code = get_rl_index(rl, last, run, level1);
01001                 if (code == rl->n) {
01002                 esc2:
01003                     put_bits(&s->pb, 1, 0);
01004                     if (level > MAX_LEVEL)
01005                         goto esc3;
01006                     run1 = run - rl->max_run[last][level] - run_diff;
01007                     if (run1 < 0)
01008                         goto esc3;
01009                     code = get_rl_index(rl, last, run1+1, level);
01010                     if (s->msmpeg4_version == 4 && code == rl->n)
01011                         goto esc3;
01012                     code = get_rl_index(rl, last, run1, level);
01013                     if (code == rl->n) {
01014                     esc3:
01015                         /* third escape */
01016                         put_bits(&s->pb, 1, 0);
01017                         put_bits(&s->pb, 1, last);
01018                         if(s->msmpeg4_version>=4){
01019                             if(s->esc3_level_length==0){
01020                                 s->esc3_level_length=8;
01021                                 s->esc3_run_length= 6;
01022                                 //ESCLVLSZ + ESCRUNSZ
01023                                 if(s->qscale<8)
01024                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
01025                                 else
01026                                     put_bits(&s->pb, 8, 3);
01027                             }
01028                             put_bits(&s->pb, s->esc3_run_length, run);
01029                             put_bits(&s->pb, 1, sign);
01030                             put_bits(&s->pb, s->esc3_level_length, level);
01031                         }else{
01032                             put_bits(&s->pb, 6, run);
01033                             put_sbits(&s->pb, 8, slevel);
01034                         }
01035                     } else {
01036                         /* second escape */
01037                         put_bits(&s->pb, 1, 1);
01038                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
01039                         put_bits(&s->pb, 1, sign);
01040                     }
01041                 } else {
01042                     /* first escape */
01043                     put_bits(&s->pb, 1, 1);
01044                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
01045                     put_bits(&s->pb, 1, sign);
01046                 }
01047             } else {
01048                 put_bits(&s->pb, 1, sign);
01049             }
01050             last_non_zero = i;
01051         }
01052     }
01053 }
01054 
01055 /****************************************/
01056 /* decoding stuff */
01057 
01058 VLC ff_mb_non_intra_vlc[4];
01059 static VLC v2_dc_lum_vlc;
01060 static VLC v2_dc_chroma_vlc;
01061 static VLC v2_intra_cbpc_vlc;
01062 static VLC v2_mb_type_vlc;
01063 static VLC v2_mv_vlc;
01064 VLC ff_inter_intra_vlc;
01065 
01066 /* This is identical to h263 except that its range is multiplied by 2. */
01067 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
01068 {
01069     int code, val, sign, shift;
01070 
01071     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
01072 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
01073     if (code < 0)
01074         return 0xffff;
01075 
01076     if (code == 0)
01077         return pred;
01078     sign = get_bits1(&s->gb);
01079     shift = f_code - 1;
01080     val = code;
01081     if (shift) {
01082         val = (val - 1) << shift;
01083         val |= get_bits(&s->gb, shift);
01084         val++;
01085     }
01086     if (sign)
01087         val = -val;
01088 
01089     val += pred;
01090     if (val <= -64)
01091         val += 64;
01092     else if (val >= 64)
01093         val -= 64;
01094 
01095     return val;
01096 }
01097 
01098 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
01099 {
01100     int cbp, code, i;
01101 
01102     if (s->pict_type == FF_P_TYPE) {
01103         if (s->use_skip_mb_code) {
01104             if (get_bits1(&s->gb)) {
01105                 /* skip mb */
01106                 s->mb_intra = 0;
01107                 for(i=0;i<6;i++)
01108                     s->block_last_index[i] = -1;
01109                 s->mv_dir = MV_DIR_FORWARD;
01110                 s->mv_type = MV_TYPE_16X16;
01111                 s->mv[0][0][0] = 0;
01112                 s->mv[0][0][1] = 0;
01113                 s->mb_skipped = 1;
01114                 return 0;
01115             }
01116         }
01117 
01118         if(s->msmpeg4_version==2)
01119             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
01120         else
01121             code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
01122         if(code<0 || code>7){
01123             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
01124             return -1;
01125         }
01126 
01127         s->mb_intra = code >>2;
01128 
01129         cbp = code & 0x3;
01130     } else {
01131         s->mb_intra = 1;
01132         if(s->msmpeg4_version==2)
01133             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
01134         else
01135             cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
01136         if(cbp<0 || cbp>3){
01137             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
01138             return -1;
01139         }
01140     }
01141 
01142     if (!s->mb_intra) {
01143         int mx, my, cbpy;
01144 
01145         cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
01146         if(cbpy<0){
01147             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
01148             return -1;
01149         }
01150 
01151         cbp|= cbpy<<2;
01152         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
01153 
01154         h263_pred_motion(s, 0, 0, &mx, &my);
01155         mx= msmpeg4v2_decode_motion(s, mx, 1);
01156         my= msmpeg4v2_decode_motion(s, my, 1);
01157 
01158         s->mv_dir = MV_DIR_FORWARD;
01159         s->mv_type = MV_TYPE_16X16;
01160         s->mv[0][0][0] = mx;
01161         s->mv[0][0][1] = my;
01162     } else {
01163         if(s->msmpeg4_version==2){
01164             s->ac_pred = get_bits1(&s->gb);
01165             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
01166         } else{
01167             s->ac_pred = 0;
01168             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
01169             if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
01170         }
01171     }
01172 
01173     s->dsp.clear_blocks(s->block[0]);
01174     for (i = 0; i < 6; i++) {
01175         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
01176         {
01177              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
01178              return -1;
01179         }
01180     }
01181     return 0;
01182 }
01183 
01184 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
01185 {
01186     int cbp, code, i;
01187     uint8_t *coded_val;
01188     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
01189 
01190     if (s->pict_type == FF_P_TYPE) {
01191         if (s->use_skip_mb_code) {
01192             if (get_bits1(&s->gb)) {
01193                 /* skip mb */
01194                 s->mb_intra = 0;
01195                 for(i=0;i<6;i++)
01196                     s->block_last_index[i] = -1;
01197                 s->mv_dir = MV_DIR_FORWARD;
01198                 s->mv_type = MV_TYPE_16X16;
01199                 s->mv[0][0][0] = 0;
01200                 s->mv[0][0][1] = 0;
01201                 s->mb_skipped = 1;
01202                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
01203 
01204                 return 0;
01205             }
01206         }
01207 
01208         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
01209         if (code < 0)
01210             return -1;
01211         //s->mb_intra = (code & 0x40) ? 0 : 1;
01212         s->mb_intra = (~code & 0x40) >> 6;
01213 
01214         cbp = code & 0x3f;
01215     } else {
01216         s->mb_intra = 1;
01217         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
01218         if (code < 0)
01219             return -1;
01220         /* predict coded block pattern */
01221         cbp = 0;
01222         for(i=0;i<6;i++) {
01223             int val = ((code >> (5 - i)) & 1);
01224             if (i < 4) {
01225                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
01226                 val = val ^ pred;
01227                 *coded_val = val;
01228             }
01229             cbp |= val << (5 - i);
01230         }
01231     }
01232 
01233     if (!s->mb_intra) {
01234         int mx, my;
01235 //printf("P at %d %d\n", s->mb_x, s->mb_y);
01236         if(s->per_mb_rl_table && cbp){
01237             s->rl_table_index = decode012(&s->gb);
01238             s->rl_chroma_table_index = s->rl_table_index;
01239         }
01240         h263_pred_motion(s, 0, 0, &mx, &my);
01241         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
01242             return -1;
01243         s->mv_dir = MV_DIR_FORWARD;
01244         s->mv_type = MV_TYPE_16X16;
01245         s->mv[0][0][0] = mx;
01246         s->mv[0][0][1] = my;
01247         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
01248     } else {
01249 //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));
01250         s->ac_pred = get_bits1(&s->gb);
01251         *mb_type_ptr = MB_TYPE_INTRA;
01252         if(s->inter_intra_pred){
01253             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
01254 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
01255         }
01256         if(s->per_mb_rl_table && cbp){
01257             s->rl_table_index = decode012(&s->gb);
01258             s->rl_chroma_table_index = s->rl_table_index;
01259         }
01260     }
01261 
01262     s->dsp.clear_blocks(s->block[0]);
01263     for (i = 0; i < 6; i++) {
01264         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
01265         {
01266             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
01267             return -1;
01268         }
01269     }
01270 
01271     return 0;
01272 }
01273 
01274 /* init all vlc decoding tables */
01275 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
01276 {
01277     MpegEncContext *s = avctx->priv_data;
01278     static int done = 0;
01279     int i;
01280     MVTable *mv;
01281 
01282     ff_h263_decode_init(avctx);
01283 
01284     common_init(s);
01285 
01286     if (!done) {
01287         done = 1;
01288 
01289         for(i=0;i<NB_RL_TABLES;i++) {
01290             init_rl(&rl_table[i], static_rl_table_store[i]);
01291         }
01292         INIT_VLC_RL(rl_table[0], 642);
01293         INIT_VLC_RL(rl_table[1], 1104);
01294         INIT_VLC_RL(rl_table[2], 554);
01295         INIT_VLC_RL(rl_table[3], 940);
01296         INIT_VLC_RL(rl_table[4], 962);
01297         INIT_VLC_RL(rl_table[5], 554);
01298 
01299         mv = &mv_tables[0];
01300         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
01301                     mv->table_mv_bits, 1, 1,
01302                     mv->table_mv_code, 2, 2, 3714);
01303         mv = &mv_tables[1];
01304         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
01305                     mv->table_mv_bits, 1, 1,
01306                     mv->table_mv_code, 2, 2, 2694);
01307 
01308         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
01309                  &ff_table0_dc_lum[0][1], 8, 4,
01310                  &ff_table0_dc_lum[0][0], 8, 4, 1158);
01311         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
01312                  &ff_table0_dc_chroma[0][1], 8, 4,
01313                  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
01314         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
01315                  &ff_table1_dc_lum[0][1], 8, 4,
01316                  &ff_table1_dc_lum[0][0], 8, 4, 1476);
01317         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
01318                  &ff_table1_dc_chroma[0][1], 8, 4,
01319                  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
01320 
01321         INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
01322                  &v2_dc_lum_table[0][1], 8, 4,
01323                  &v2_dc_lum_table[0][0], 8, 4, 1472);
01324         INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
01325                  &v2_dc_chroma_table[0][1], 8, 4,
01326                  &v2_dc_chroma_table[0][0], 8, 4, 1506);
01327 
01328         INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
01329                  &v2_intra_cbpc[0][1], 2, 1,
01330                  &v2_intra_cbpc[0][0], 2, 1, 8);
01331         INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
01332                  &v2_mb_type[0][1], 2, 1,
01333                  &v2_mb_type[0][0], 2, 1, 128);
01334         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
01335                  &mvtab[0][1], 2, 1,
01336                  &mvtab[0][0], 2, 1, 538);
01337 
01338         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
01339                      &wmv2_inter_table[0][0][1], 8, 4,
01340                      &wmv2_inter_table[0][0][0], 8, 4, 1636);
01341         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
01342                      &wmv2_inter_table[1][0][1], 8, 4,
01343                      &wmv2_inter_table[1][0][0], 8, 4, 2648);
01344         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
01345                      &wmv2_inter_table[2][0][1], 8, 4,
01346                      &wmv2_inter_table[2][0][0], 8, 4, 1532);
01347         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
01348                      &wmv2_inter_table[3][0][1], 8, 4,
01349                      &wmv2_inter_table[3][0][0], 8, 4, 2488);
01350 
01351         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
01352                  &ff_msmp4_mb_i_table[0][1], 4, 2,
01353                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
01354 
01355         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
01356                  &table_inter_intra[0][1], 2, 1,
01357                  &table_inter_intra[0][0], 2, 1, 8);
01358     }
01359 
01360     switch(s->msmpeg4_version){
01361     case 1:
01362     case 2:
01363         s->decode_mb= msmpeg4v12_decode_mb;
01364         break;
01365     case 3:
01366     case 4:
01367         s->decode_mb= msmpeg4v34_decode_mb;
01368         break;
01369     case 5:
01370         if (CONFIG_WMV2_DECODER)
01371             s->decode_mb= ff_wmv2_decode_mb;
01372     case 6:
01373         //FIXME + TODO VC1 decode mb
01374         break;
01375     }
01376 
01377     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
01378 
01379     return 0;
01380 }
01381 
01382 int msmpeg4_decode_picture_header(MpegEncContext * s)
01383 {
01384     int code;
01385 
01386 #if 0
01387 {
01388 int i;
01389 for(i=0; i<s->gb.size_in_bits; i++)
01390     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
01391 //    get_bits1(&s->gb);
01392 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
01393 return -1;
01394 }
01395 #endif
01396 
01397     if(s->msmpeg4_version==1){
01398         int start_code;
01399         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
01400         if(start_code!=0x00000100){
01401             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
01402             return -1;
01403         }
01404 
01405         skip_bits(&s->gb, 5); // frame number */
01406     }
01407 
01408     s->pict_type = get_bits(&s->gb, 2) + 1;
01409     if (s->pict_type != FF_I_TYPE &&
01410         s->pict_type != FF_P_TYPE){
01411         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
01412         return -1;
01413     }
01414 #if 0
01415 {
01416     static int had_i=0;
01417     if(s->pict_type == FF_I_TYPE) had_i=1;
01418     if(!had_i) return -1;
01419 }
01420 #endif
01421     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
01422     if(s->qscale==0){
01423         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
01424         return -1;
01425     }
01426 
01427     if (s->pict_type == FF_I_TYPE) {
01428         code = get_bits(&s->gb, 5);
01429         if(s->msmpeg4_version==1){
01430             if(code==0 || code>s->mb_height){
01431                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
01432                 return -1;
01433             }
01434 
01435             s->slice_height = code;
01436         }else{
01437             /* 0x17: one slice, 0x18: two slices, ... */
01438             if (code < 0x17){
01439                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
01440                 return -1;
01441             }
01442 
01443             s->slice_height = s->mb_height / (code - 0x16);
01444         }
01445 
01446         switch(s->msmpeg4_version){
01447         case 1:
01448         case 2:
01449             s->rl_chroma_table_index = 2;
01450             s->rl_table_index = 2;
01451 
01452             s->dc_table_index = 0; //not used
01453             break;
01454         case 3:
01455             s->rl_chroma_table_index = decode012(&s->gb);
01456             s->rl_table_index = decode012(&s->gb);
01457 
01458             s->dc_table_index = get_bits1(&s->gb);
01459             break;
01460         case 4:
01461             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
01462 
01463             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
01464             else                           s->per_mb_rl_table= 0;
01465 
01466             if(!s->per_mb_rl_table){
01467                 s->rl_chroma_table_index = decode012(&s->gb);
01468                 s->rl_table_index = decode012(&s->gb);
01469             }
01470 
01471             s->dc_table_index = get_bits1(&s->gb);
01472             s->inter_intra_pred= 0;
01473             break;
01474         }
01475         s->no_rounding = 1;
01476         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
01477             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
01478                 s->qscale,
01479                 s->rl_chroma_table_index,
01480                 s->rl_table_index,
01481                 s->dc_table_index,
01482                 s->per_mb_rl_table,
01483                 s->slice_height);
01484     } else {
01485         switch(s->msmpeg4_version){
01486         case 1:
01487         case 2:
01488             if(s->msmpeg4_version==1)
01489                 s->use_skip_mb_code = 1;
01490             else
01491                 s->use_skip_mb_code = get_bits1(&s->gb);
01492             s->rl_table_index = 2;
01493             s->rl_chroma_table_index = s->rl_table_index;
01494             s->dc_table_index = 0; //not used
01495             s->mv_table_index = 0;
01496             break;
01497         case 3:
01498             s->use_skip_mb_code = get_bits1(&s->gb);
01499             s->rl_table_index = decode012(&s->gb);
01500             s->rl_chroma_table_index = s->rl_table_index;
01501 
01502             s->dc_table_index = get_bits1(&s->gb);
01503 
01504             s->mv_table_index = get_bits1(&s->gb);
01505             break;
01506         case 4:
01507             s->use_skip_mb_code = get_bits1(&s->gb);
01508 
01509             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
01510             else                           s->per_mb_rl_table= 0;
01511 
01512             if(!s->per_mb_rl_table){
01513                 s->rl_table_index = decode012(&s->gb);
01514                 s->rl_chroma_table_index = s->rl_table_index;
01515             }
01516 
01517             s->dc_table_index = get_bits1(&s->gb);
01518 
01519             s->mv_table_index = get_bits1(&s->gb);
01520             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
01521             break;
01522         }
01523 
01524         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
01525             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
01526                 s->use_skip_mb_code,
01527                 s->rl_table_index,
01528                 s->rl_chroma_table_index,
01529                 s->dc_table_index,
01530                 s->mv_table_index,
01531                 s->per_mb_rl_table,
01532                 s->qscale);
01533 
01534         if(s->flipflop_rounding){
01535             s->no_rounding ^= 1;
01536         }else{
01537             s->no_rounding = 0;
01538         }
01539     }
01540 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
01541 
01542     s->esc3_level_length= 0;
01543     s->esc3_run_length= 0;
01544 
01545     return 0;
01546 }
01547 
01548 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
01549 {
01550     int left= buf_size*8 - get_bits_count(&s->gb);
01551     int length= s->msmpeg4_version>=3 ? 17 : 16;
01552     /* the alt_bitstream reader could read over the end so we need to check it */
01553     if(left>=length && left<length+8)
01554     {
01555         int fps;
01556 
01557         fps= get_bits(&s->gb, 5);
01558         s->bit_rate= get_bits(&s->gb, 11)*1024;
01559         if(s->msmpeg4_version>=3)
01560             s->flipflop_rounding= get_bits1(&s->gb);
01561         else
01562             s->flipflop_rounding= 0;
01563 
01564 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
01565     }
01566     else if(left<length+8)
01567     {
01568         s->flipflop_rounding= 0;
01569         if(s->msmpeg4_version != 2)
01570             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
01571     }
01572     else
01573     {
01574         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
01575     }
01576 
01577     return 0;
01578 }
01579 
01580 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
01581 {
01582     int level, pred;
01583 
01584     if(s->msmpeg4_version<=2){
01585         if (n < 4) {
01586             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
01587         } else {
01588             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
01589         }
01590         if (level < 0)
01591             return -1;
01592         level-=256;
01593     }else{  //FIXME optimize use unified tables & index
01594         if (n < 4) {
01595             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01596         } else {
01597             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01598         }
01599         if (level < 0){
01600             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
01601             return -1;
01602         }
01603 
01604         if (level == DC_MAX) {
01605             level = get_bits(&s->gb, 8);
01606             if (get_bits1(&s->gb))
01607                 level = -level;
01608         } else if (level != 0) {
01609             if (get_bits1(&s->gb))
01610                 level = -level;
01611         }
01612     }
01613 
01614     if(s->msmpeg4_version==1){
01615         int32_t *dc_val;
01616         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
01617         level += pred;
01618 
01619         /* update predictor */
01620         *dc_val= level;
01621     }else{
01622         int16_t *dc_val;
01623         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
01624         level += pred;
01625 
01626         /* update predictor */
01627         if (n < 4) {
01628             *dc_val = level * s->y_dc_scale;
01629         } else {
01630             *dc_val = level * s->c_dc_scale;
01631         }
01632     }
01633 
01634     return level;
01635 }
01636 
01637 //#define ERROR_DETAILS
01638 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
01639                               int n, int coded, const uint8_t *scan_table)
01640 {
01641     int level, i, last, run, run_diff;
01642     int av_uninit(dc_pred_dir);
01643     RLTable *rl;
01644     RL_VLC_ELEM *rl_vlc;
01645     int qmul, qadd;
01646 
01647     if (s->mb_intra) {
01648         qmul=1;
01649         qadd=0;
01650 
01651         /* DC coef */
01652         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
01653 
01654         if (level < 0){
01655             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
01656             if(s->inter_intra_pred) level=0;
01657             else                    return -1;
01658         }
01659         if (n < 4) {
01660             rl = &rl_table[s->rl_table_index];
01661             if(level > 256*s->y_dc_scale){
01662                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
01663                 if(!s->inter_intra_pred) return -1;
01664             }
01665         } else {
01666             rl = &rl_table[3 + s->rl_chroma_table_index];
01667             if(level > 256*s->c_dc_scale){
01668                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
01669                 if(!s->inter_intra_pred) return -1;
01670             }
01671         }
01672         block[0] = level;
01673 
01674         run_diff = s->msmpeg4_version >= 4;
01675         i = 0;
01676         if (!coded) {
01677             goto not_coded;
01678         }
01679         if (s->ac_pred) {
01680             if (dc_pred_dir == 0)
01681                 scan_table = s->intra_v_scantable.permutated; /* left */
01682             else
01683                 scan_table = s->intra_h_scantable.permutated; /* top */
01684         } else {
01685             scan_table = s->intra_scantable.permutated;
01686         }
01687         rl_vlc= rl->rl_vlc[0];
01688     } else {
01689         qmul = s->qscale << 1;
01690         qadd = (s->qscale - 1) | 1;
01691         i = -1;
01692         rl = &rl_table[3 + s->rl_table_index];
01693 
01694         if(s->msmpeg4_version==2)
01695             run_diff = 0;
01696         else
01697             run_diff = 1;
01698 
01699         if (!coded) {
01700             s->block_last_index[n] = i;
01701             return 0;
01702         }
01703         if(!scan_table)
01704             scan_table = s->inter_scantable.permutated;
01705         rl_vlc= rl->rl_vlc[s->qscale];
01706     }
01707   {
01708     OPEN_READER(re, &s->gb);
01709     for(;;) {
01710         UPDATE_CACHE(re, &s->gb);
01711         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
01712         if (level==0) {
01713             int cache;
01714             cache= GET_CACHE(re, &s->gb);
01715             /* escape */
01716             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
01717                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
01718                     /* third escape */
01719                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
01720                     UPDATE_CACHE(re, &s->gb);
01721                     if(s->msmpeg4_version<=3){
01722                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
01723                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
01724                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
01725                         SKIP_COUNTER(re, &s->gb, 1+6+8);
01726                     }else{
01727                         int sign;
01728                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
01729                         if(!s->esc3_level_length){
01730                             int ll;
01731                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
01732                             if(s->qscale<8){
01733                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
01734                                 if(ll==0){
01735                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
01736                                 }
01737                             }else{
01738                                 ll=2;
01739                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
01740                                     ll++;
01741                                     SKIP_BITS(re, &s->gb, 1);
01742                                 }
01743                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
01744                             }
01745 
01746                             s->esc3_level_length= ll;
01747                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
01748 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
01749                             UPDATE_CACHE(re, &s->gb);
01750                         }
01751                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
01752                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
01753 
01754                         sign=  SHOW_UBITS(re, &s->gb, 1);
01755                         SKIP_BITS(re, &s->gb, 1);
01756 
01757                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
01758                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
01759                         if(sign) level= -level;
01760                     }
01761 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
01762 #if 0 // waste of time / this will detect very few errors
01763                     {
01764                         const int abs_level= FFABS(level);
01765                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
01766                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
01767                             if(abs_level <= rl->max_level[last][run]){
01768                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
01769                                 return DECODING_AC_LOST;
01770                             }
01771                             if(abs_level <= rl->max_level[last][run]*2){
01772                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
01773                                 return DECODING_AC_LOST;
01774                             }
01775                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
01776                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
01777                                 return DECODING_AC_LOST;
01778                             }
01779                         }
01780                     }
01781 #endif
01782                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
01783                     if (level>0) level= level * qmul + qadd;
01784                     else         level= level * qmul - qadd;
01785 #if 0 // waste of time too :(
01786                     if(level>2048 || level<-2048){
01787                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
01788                         return DECODING_AC_LOST;
01789                     }
01790 #endif
01791                     i+= run + 1;
01792                     if(last) i+=192;
01793 #ifdef ERROR_DETAILS
01794                 if(run==66)
01795                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
01796                 else if((i>62 && i<192) || i>192+63)
01797                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
01798 #endif
01799                 } else {
01800                     /* second escape */
01801 #if MIN_CACHE_BITS < 23
01802                     LAST_SKIP_BITS(re, &s->gb, 2);
01803                     UPDATE_CACHE(re, &s->gb);
01804 #else
01805                     SKIP_BITS(re, &s->gb, 2);
01806 #endif
01807                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01808                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
01809                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01810                     LAST_SKIP_BITS(re, &s->gb, 1);
01811 #ifdef ERROR_DETAILS
01812                 if(run==66)
01813                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
01814                 else if((i>62 && i<192) || i>192+63)
01815                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
01816 #endif
01817                 }
01818             } else {
01819                 /* first escape */
01820 #if MIN_CACHE_BITS < 22
01821                 LAST_SKIP_BITS(re, &s->gb, 1);
01822                 UPDATE_CACHE(re, &s->gb);
01823 #else
01824                 SKIP_BITS(re, &s->gb, 1);
01825 #endif
01826                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01827                 i+= run;
01828                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
01829                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01830                 LAST_SKIP_BITS(re, &s->gb, 1);
01831 #ifdef ERROR_DETAILS
01832                 if(run==66)
01833                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
01834                 else if((i>62 && i<192) || i>192+63)
01835                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
01836 #endif
01837             }
01838         } else {
01839             i+= run;
01840             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01841             LAST_SKIP_BITS(re, &s->gb, 1);
01842 #ifdef ERROR_DETAILS
01843                 if(run==66)
01844                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
01845                 else if((i>62 && i<192) || i>192+63)
01846                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
01847 #endif
01848         }
01849         if (i > 62){
01850             i-= 192;
01851             if(i&(~63)){
01852                 const int left= get_bits_left(&s->gb);
01853                 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
01854                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
01855                     break;
01856                 }else{
01857                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
01858                     return -1;
01859                 }
01860             }
01861 
01862             block[scan_table[i]] = level;
01863             break;
01864         }
01865 
01866         block[scan_table[i]] = level;
01867     }
01868     CLOSE_READER(re, &s->gb);
01869   }
01870  not_coded:
01871     if (s->mb_intra) {
01872         mpeg4_pred_ac(s, block, n, dc_pred_dir);
01873         if (s->ac_pred) {
01874             i = 63; /* XXX: not optimal */
01875         }
01876     }
01877     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
01878     s->block_last_index[n] = i;
01879 
01880     return 0;
01881 }
01882 
01883 int ff_msmpeg4_decode_motion(MpegEncContext * s,
01884                                  int *mx_ptr, int *my_ptr)
01885 {
01886     MVTable *mv;
01887     int code, mx, my;
01888 
01889     mv = &mv_tables[s->mv_table_index];
01890 
01891     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
01892     if (code < 0){
01893         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
01894         return -1;
01895     }
01896     if (code == mv->n) {
01897 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
01898         mx = get_bits(&s->gb, 6);
01899         my = get_bits(&s->gb, 6);
01900     } else {
01901         mx = mv->table_mvx[code];
01902         my = mv->table_mvy[code];
01903     }
01904 
01905     mx += *mx_ptr - 32;
01906     my += *my_ptr - 32;
01907     /* WARNING : they do not do exactly modulo encoding */
01908     if (mx <= -64)
01909         mx += 64;
01910     else if (mx >= 64)
01911         mx -= 64;
01912 
01913     if (my <= -64)
01914         my += 64;
01915     else if (my >= 64)
01916         my -= 64;
01917     *mx_ptr = mx;
01918     *my_ptr = my;
01919     return 0;
01920 }
01921 
01922 AVCodec msmpeg4v1_decoder = {
01923     "msmpeg4v1",
01924     AVMEDIA_TYPE_VIDEO,
01925     CODEC_ID_MSMPEG4V1,
01926     sizeof(MpegEncContext),
01927     ff_msmpeg4_decode_init,
01928     NULL,
01929     ff_h263_decode_end,
01930     ff_h263_decode_frame,
01931     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
01932     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
01933     .pix_fmts= ff_pixfmt_list_420,
01934 };
01935 
01936 AVCodec msmpeg4v2_decoder = {
01937     "msmpeg4v2",
01938     AVMEDIA_TYPE_VIDEO,
01939     CODEC_ID_MSMPEG4V2,
01940     sizeof(MpegEncContext),
01941     ff_msmpeg4_decode_init,
01942     NULL,
01943     ff_h263_decode_end,
01944     ff_h263_decode_frame,
01945     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
01946     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
01947     .pix_fmts= ff_pixfmt_list_420,
01948 };
01949 
01950 AVCodec msmpeg4v3_decoder = {
01951     "msmpeg4",
01952     AVMEDIA_TYPE_VIDEO,
01953     CODEC_ID_MSMPEG4V3,
01954     sizeof(MpegEncContext),
01955     ff_msmpeg4_decode_init,
01956     NULL,
01957     ff_h263_decode_end,
01958     ff_h263_decode_frame,
01959     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
01960     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
01961     .pix_fmts= ff_pixfmt_list_420,
01962 };
01963 
01964 AVCodec wmv1_decoder = {
01965     "wmv1",
01966     AVMEDIA_TYPE_VIDEO,
01967     CODEC_ID_WMV1,
01968     sizeof(MpegEncContext),
01969     ff_msmpeg4_decode_init,
01970     NULL,
01971     ff_h263_decode_end,
01972     ff_h263_decode_frame,
01973     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
01974     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
01975     .pix_fmts= ff_pixfmt_list_420,
01976 };