CONFIG_ENCODERS cleanup
[ffmpeg.git] / libavcodec / msmpeg4.c
1 /*
2  * MSMPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
20  */
21
22 /**
23  * @file msmpeg4.c
24  * MSMPEG4 backend for ffmpeg encoder and decoder.
25  */
26
27 #include "avcodec.h"
28 #include "dsputil.h"
29 #include "mpegvideo.h"
30
31 /*
32  * You can also call this codec : MPEG4 with a twist ! 
33  *
34  * TODO: 
35  *        - (encoding) select best mv table (two choices)
36  *        - (encoding) select best vlc/dc table 
37  */
38 //#define DEBUG
39
40 #define DC_VLC_BITS 9
41 #define CBPY_VLC_BITS 6
42 #define INTER_INTRA_VLC_BITS 3
43 #define V1_INTRA_CBPC_VLC_BITS 6
44 #define V1_INTER_CBPC_VLC_BITS 6
45 #define V2_INTRA_CBPC_VLC_BITS 3
46 #define V2_MB_TYPE_VLC_BITS 7
47 #define MV_VLC_BITS 9
48 #define V2_MV_VLC_BITS 9
49 #define TEX_VLC_BITS 9
50 #define MB_NON_INTRA_VLC_BITS 9
51 #define MB_INTRA_VLC_BITS 9
52
53 #define II_BITRATE 128*1024
54 #define MBAC_BITRATE 50*1024
55
56 #define DEFAULT_INTER_INDEX 3
57
58 static uint32_t v2_dc_lum_table[512][2];
59 static uint32_t v2_dc_chroma_table[512][2];
60
61 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
62 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
63                                        int n, int coded, const uint8_t *scantable);
64 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
65 static int msmpeg4_decode_motion(MpegEncContext * s, 
66                                  int *mx_ptr, int *my_ptr);
67 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
68 static void init_h263_dc_for_msmpeg4(void);
69 static inline void msmpeg4_memsetw(short *tab, int val, int n);
70 #ifdef CONFIG_ENCODERS
71 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
72 #endif //CONFIG_ENCODERS
73 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
74 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
76
77
78 #ifdef DEBUG
79 int intra_count = 0;
80 int frame_count = 0;
81 #endif
82
83 #include "msmpeg4data.h"
84
85 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
86 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
87 #endif //CONFIG_ENCODERS
88
89 #ifdef STATS
90
91 const char *st_names[ST_NB] = {
92     "unknown",
93     "dc",
94     "intra_ac",
95     "inter_ac",
96     "intra_mb",
97     "inter_mb",
98     "mv",
99 };
100
101 int st_current_index = 0;
102 unsigned int st_bit_counts[ST_NB];
103 unsigned int st_out_bit_counts[ST_NB];
104
105 #define set_stat(var) st_current_index = var;
106
107 void print_stats(void)
108 {
109     unsigned int total;
110     int i;
111
112     printf("Input:\n");
113     total = 0;
114     for(i=0;i<ST_NB;i++)
115         total += st_bit_counts[i];
116     if (total == 0)
117         total = 1;
118     for(i=0;i<ST_NB;i++) {
119         printf("%-10s : %10.1f %5.1f%%\n", 
120                st_names[i], 
121                (double)st_bit_counts[i] / 8.0, 
122                (double)st_bit_counts[i] * 100.0 / total);
123     }
124     printf("%-10s : %10.1f %5.1f%%\n",
125            "total", 
126            (double)total / 8.0, 
127            100.0);
128
129     printf("Output:\n");
130     total = 0;
131     for(i=0;i<ST_NB;i++)
132         total += st_out_bit_counts[i];
133     if (total == 0)
134         total = 1;
135     for(i=0;i<ST_NB;i++) {
136         printf("%-10s : %10.1f %5.1f%%\n", 
137                st_names[i], 
138                (double)st_out_bit_counts[i] / 8.0, 
139                (double)st_out_bit_counts[i] * 100.0 / total);
140     }
141     printf("%-10s : %10.1f %5.1f%%\n",
142            "total", 
143            (double)total / 8.0, 
144            100.0);
145 }
146
147 #else
148
149 #define set_stat(var)
150
151 #endif
152
153 static void common_init(MpegEncContext * s)
154 {
155     static int inited=0;
156     
157     switch(s->msmpeg4_version){
158     case 1:
159     case 2:
160         s->y_dc_scale_table=
161         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
162         break;
163     case 3:
164         if(s->workaround_bugs){
165             s->y_dc_scale_table= old_ff_y_dc_scale_table;
166             s->c_dc_scale_table= old_ff_c_dc_scale_table;
167         } else{
168             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
169             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
170         }
171         break;
172     case 4:
173     case 5:
174         s->y_dc_scale_table= wmv1_y_dc_scale_table;
175         s->c_dc_scale_table= wmv1_c_dc_scale_table;
176         break;
177     }
178
179     
180     if(s->msmpeg4_version>=4){
181         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
182         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
183         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
184         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
185     }
186     //Note the default tables are set in common_init in mpegvideo.c
187     
188     if(!inited){
189         inited=1;
190
191         init_h263_dc_for_msmpeg4();
192     }
193 }
194
195 #ifdef CONFIG_ENCODERS
196
197 /* build the table which associate a (x,y) motion vector to a vlc */
198 static void init_mv_table(MVTable *tab)
199 {
200     int i, x, y;
201
202     tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
203     /* mark all entries as not used */
204     for(i=0;i<4096;i++)
205         tab->table_mv_index[i] = tab->n;
206     
207     for(i=0;i<tab->n;i++) {
208         x = tab->table_mvx[i];
209         y = tab->table_mvy[i];
210         tab->table_mv_index[(x << 6) | y] = i;
211     }
212 }
213
214 static void code012(PutBitContext *pb, int n)
215 {
216     if (n == 0) {
217         put_bits(pb, 1, 0);
218     } else {
219         put_bits(pb, 1, 1);
220         put_bits(pb, 1, (n >= 2));
221     }
222 }
223
224 void ff_msmpeg4_encode_init(MpegEncContext *s)
225 {
226     static int init_done=0;
227     int i;
228
229     common_init(s);
230     if(s->msmpeg4_version>=4){
231         s->min_qcoeff= -255;
232         s->max_qcoeff=  255;
233     }
234
235     if (!init_done) {
236         /* init various encoding tables */
237         init_done = 1;
238         init_mv_table(&mv_tables[0]);
239         init_mv_table(&mv_tables[1]);
240         for(i=0;i<NB_RL_TABLES;i++)
241             init_rl(&rl_table[i]);
242
243         for(i=0; i<NB_RL_TABLES; i++){
244             int level;
245             for(level=0; level<=MAX_LEVEL; level++){
246                 int run;
247                 for(run=0; run<=MAX_RUN; run++){
248                     int last;
249                     for(last=0; last<2; last++){
250                         rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
251                     }
252                 }
253             }
254         }
255     }
256 }
257
258 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
259     int size=0;
260     int code;
261     int run_diff= intra ? 0 : 1;
262     
263     code = get_rl_index(rl, last, run, level);
264     size+= rl->table_vlc[code][1];
265     if (code == rl->n) {
266         int level1, run1;
267
268         level1 = level - rl->max_level[last][run];
269         if (level1 < 1) 
270             goto esc2;
271         code = get_rl_index(rl, last, run, level1);
272         if (code == rl->n) {
273             esc2:
274             size++;
275             if (level > MAX_LEVEL)
276                 goto esc3;
277             run1 = run - rl->max_run[last][level] - run_diff;
278             if (run1 < 0)
279                 goto esc3;
280             code = get_rl_index(rl, last, run1, level);
281             if (code == rl->n) {
282             esc3:
283                 /* third escape */
284                 size+=1+1+6+8;
285             } else {
286                 /* second escape */
287                 size+= 1+1+ rl->table_vlc[code][1];
288             }
289         } else {
290             /* first escape */
291             size+= 1+1+ rl->table_vlc[code][1];
292         }
293     } else {
294         size++;
295     }
296     return size;
297 }
298
299 static void find_best_tables(MpegEncContext * s)
300 {
301     int i;
302     int best       =-1, best_size       =9999999;
303     int chroma_best=-1, best_chroma_size=9999999;
304
305     for(i=0; i<3; i++){
306         int level;
307         int chroma_size=0;
308         int size=0;
309
310         if(i>0){// ;)
311             size++; 
312             chroma_size++;
313         }
314         for(level=0; level<=MAX_LEVEL; level++){
315             int run;
316             for(run=0; run<=MAX_RUN; run++){
317                 int last;
318                 const int last_size= size + chroma_size;
319                 for(last=0; last<2; last++){
320                     int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
321                     int intra_luma_count  = s->ac_stats[1][0][level][run][last];
322                     int intra_chroma_count= s->ac_stats[1][1][level][run][last];
323                     
324                     if(s->pict_type==I_TYPE){
325                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
326                         chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
327                     }else{
328                         size+=        intra_luma_count  *rl_length[i  ][level][run][last]
329                                      +intra_chroma_count*rl_length[i+3][level][run][last]
330                                      +inter_count       *rl_length[i+3][level][run][last];
331                     }                   
332                 }
333                 if(last_size == size+chroma_size) break;
334             }
335         }
336         if(size<best_size){
337             best_size= size;
338             best= i;
339         }
340         if(chroma_size<best_chroma_size){
341             best_chroma_size= chroma_size;
342             chroma_best= i;
343         }
344     }
345
346 //    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", 
347 //           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
348            
349     if(s->pict_type==P_TYPE) chroma_best= best;
350
351     memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
352
353     s->rl_table_index       =        best;
354     s->rl_chroma_table_index= chroma_best;
355     
356     if(s->pict_type != s->last_non_b_pict_type){
357         s->rl_table_index= 2;
358         if(s->pict_type==I_TYPE)
359             s->rl_chroma_table_index= 1;
360         else
361             s->rl_chroma_table_index= 2;
362     }
363
364 }
365
366 /* write MSMPEG4 compatible frame header */
367 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
368 {
369     find_best_tables(s);
370
371     align_put_bits(&s->pb);
372     put_bits(&s->pb, 2, s->pict_type - 1);
373
374     put_bits(&s->pb, 5, s->qscale);
375     if(s->msmpeg4_version<=2){
376         s->rl_table_index = 2;
377         s->rl_chroma_table_index = 2;
378     }
379
380     s->dc_table_index = 1;
381     s->mv_table_index = 1; /* only if P frame */
382     s->use_skip_mb_code = 1; /* only if P frame */
383     s->per_mb_rl_table = 0;
384     if(s->msmpeg4_version==4)
385         s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
386 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
387
388     if (s->pict_type == I_TYPE) {
389         s->slice_height= s->mb_height/1;
390         put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
391         
392         if(s->msmpeg4_version==4){
393             msmpeg4_encode_ext_header(s);
394             if(s->bit_rate>MBAC_BITRATE)
395                 put_bits(&s->pb, 1, s->per_mb_rl_table);
396         }
397
398         if(s->msmpeg4_version>2){
399             if(!s->per_mb_rl_table){
400                 code012(&s->pb, s->rl_chroma_table_index);
401                 code012(&s->pb, s->rl_table_index);
402             }
403
404             put_bits(&s->pb, 1, s->dc_table_index);
405         }
406     } else {
407         put_bits(&s->pb, 1, s->use_skip_mb_code);
408         
409         if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
410             put_bits(&s->pb, 1, s->per_mb_rl_table);
411
412         if(s->msmpeg4_version>2){
413             if(!s->per_mb_rl_table)
414                 code012(&s->pb, s->rl_table_index);
415
416             put_bits(&s->pb, 1, s->dc_table_index);
417
418             put_bits(&s->pb, 1, s->mv_table_index);
419         }
420     }
421
422     s->esc3_level_length= 0;
423     s->esc3_run_length= 0;
424
425 #ifdef DEBUG
426     intra_count = 0;
427     printf("*****frame %d:\n", frame_count++);
428 #endif
429 }
430
431 void msmpeg4_encode_ext_header(MpegEncContext * s)
432 {
433         put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
434
435         put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
436
437         if(s->msmpeg4_version>=3)
438             put_bits(&s->pb, 1, s->flipflop_rounding);
439         else
440             assert(s->flipflop_rounding==0);
441 }
442
443 #endif //CONFIG_ENCODERS
444
445 /* predict coded block */
446 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
447 {
448     int xy, wrap, pred, a, b, c;
449
450     xy = s->block_index[n];
451     wrap = s->block_wrap[0];
452
453     /* B C
454      * A X 
455      */
456     a = s->coded_block[xy - 1       ];
457     b = s->coded_block[xy - 1 - wrap];
458     c = s->coded_block[xy     - wrap];
459     
460     if (b == c) {
461         pred = a;
462     } else {
463         pred = c;
464     }
465     
466     /* store value */
467     *coded_block_ptr = &s->coded_block[xy];
468
469     return pred;
470 }
471
472 #ifdef CONFIG_ENCODERS
473
474 static void msmpeg4_encode_motion(MpegEncContext * s, 
475                                   int mx, int my)
476 {
477     int code;
478     MVTable *mv;
479
480     /* modulo encoding */
481     /* WARNING : you cannot reach all the MVs even with the modulo
482        encoding. This is a somewhat strange compromise they took !!!  */
483     if (mx <= -64)
484         mx += 64;
485     else if (mx >= 64)
486         mx -= 64;
487     if (my <= -64)
488         my += 64;
489     else if (my >= 64)
490         my -= 64;
491     
492     mx += 32;
493     my += 32;
494 #if 0
495     if ((unsigned)mx >= 64 ||
496         (unsigned)my >= 64) 
497         fprintf(stderr, "error mx=%d my=%d\n", mx, my);
498 #endif
499     mv = &mv_tables[s->mv_table_index];
500
501     code = mv->table_mv_index[(mx << 6) | my];
502     set_stat(ST_MV);
503     put_bits(&s->pb, 
504              mv->table_mv_bits[code], 
505              mv->table_mv_code[code]);
506     if (code == mv->n) {
507         /* escape : code litterally */
508         put_bits(&s->pb, 6, mx);
509         put_bits(&s->pb, 6, my);
510     }
511 }
512
513 static inline void handle_slices(MpegEncContext *s){
514     if (s->mb_x == 0) {
515         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
516             if(s->msmpeg4_version < 4){
517                 ff_mpeg4_clean_buffers(s);
518             }
519             s->first_slice_line = 1;
520         } else {
521             s->first_slice_line = 0; 
522         }
523     }
524 }
525
526 void msmpeg4_encode_mb(MpegEncContext * s, 
527                        DCTELEM block[6][64],
528                        int motion_x, int motion_y)
529 {
530     int cbp, coded_cbp, i;
531     int pred_x, pred_y;
532     uint8_t *coded_block;
533
534     handle_slices(s);
535     
536     if (!s->mb_intra) {
537         /* compute cbp */
538         set_stat(ST_INTER_MB);
539         cbp = 0;
540         for (i = 0; i < 6; i++) {
541             if (s->block_last_index[i] >= 0)
542                 cbp |= 1 << (5 - i);
543         }
544         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
545             /* skip macroblock */
546             put_bits(&s->pb, 1, 1);
547             s->last_bits++;
548             s->misc_bits++;
549             s->skip_count++;
550
551             return;
552         }
553         if (s->use_skip_mb_code)
554             put_bits(&s->pb, 1, 0);     /* mb coded */
555         
556         if(s->msmpeg4_version<=2){
557             put_bits(&s->pb, 
558                      v2_mb_type[cbp&3][1], 
559                      v2_mb_type[cbp&3][0]);
560             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
561             else             coded_cbp= cbp;
562
563             put_bits(&s->pb, 
564                      cbpy_tab[coded_cbp>>2][1], 
565                      cbpy_tab[coded_cbp>>2][0]);
566
567             s->misc_bits += get_bits_diff(s);
568
569             h263_pred_motion(s, 0, &pred_x, &pred_y);
570             msmpeg4v2_encode_motion(s, motion_x - pred_x);
571             msmpeg4v2_encode_motion(s, motion_y - pred_y);
572         }else{
573             put_bits(&s->pb, 
574                      table_mb_non_intra[cbp + 64][1], 
575                      table_mb_non_intra[cbp + 64][0]);
576
577             s->misc_bits += get_bits_diff(s);
578
579             /* motion vector */
580             h263_pred_motion(s, 0, &pred_x, &pred_y);
581             msmpeg4_encode_motion(s, motion_x - pred_x, 
582                                   motion_y - pred_y);
583         }
584
585         s->mv_bits += get_bits_diff(s);
586
587         for (i = 0; i < 6; i++) {
588             msmpeg4_encode_block(s, block[i], i);
589         }
590         s->p_tex_bits += get_bits_diff(s);
591     } else {
592         /* compute cbp */
593         cbp = 0;
594         coded_cbp = 0;
595         for (i = 0; i < 6; i++) {
596             int val, pred;
597             val = (s->block_last_index[i] >= 1);
598             cbp |= val << (5 - i);
599             if (i < 4) {
600                 /* predict value for close blocks only for luma */
601                 pred = coded_block_pred(s, i, &coded_block);
602                 *coded_block = val;
603                 val = val ^ pred;
604             }
605             coded_cbp |= val << (5 - i);
606         }
607 #if 0
608         if (coded_cbp)
609             printf("cbp=%x %x\n", cbp, coded_cbp);
610 #endif
611
612         if(s->msmpeg4_version<=2){
613             if (s->pict_type == I_TYPE) {
614                 put_bits(&s->pb, 
615                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
616             } else {
617                 if (s->use_skip_mb_code)
618                     put_bits(&s->pb, 1, 0);     /* mb coded */
619                 put_bits(&s->pb, 
620                          v2_mb_type[(cbp&3) + 4][1], 
621                          v2_mb_type[(cbp&3) + 4][0]);
622             }
623             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
624             put_bits(&s->pb, 
625                      cbpy_tab[cbp>>2][1], 
626                      cbpy_tab[cbp>>2][0]);
627         }else{
628             if (s->pict_type == I_TYPE) {
629                 set_stat(ST_INTRA_MB);
630                 put_bits(&s->pb, 
631                          table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
632             } else {
633                 if (s->use_skip_mb_code)
634                     put_bits(&s->pb, 1, 0);     /* mb coded */
635                 put_bits(&s->pb, 
636                          table_mb_non_intra[cbp][1], 
637                          table_mb_non_intra[cbp][0]);
638             }
639             set_stat(ST_INTRA_MB);
640             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
641             if(s->inter_intra_pred){
642                 s->h263_aic_dir=0;
643                 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
644             }
645         }
646         s->misc_bits += get_bits_diff(s);
647
648         for (i = 0; i < 6; i++) {
649             msmpeg4_encode_block(s, block[i], i);
650         }
651         s->i_tex_bits += get_bits_diff(s);
652         s->i_count++;
653     }
654 }
655
656 #endif //CONFIG_ENCODERS
657
658 /* old ffmpeg msmpeg4v3 mode */
659 static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
660 {
661     if (s->qscale < 5){
662         s->y_dc_scale = 8;
663         s->c_dc_scale = 8;
664     }else if (s->qscale < 9){
665         s->y_dc_scale = 2 * s->qscale;
666         s->c_dc_scale = (s->qscale + 13)>>1;
667     }else{
668         s->y_dc_scale = s->qscale + 8;
669         s->c_dc_scale = (s->qscale + 13)>>1;
670     }
671 }
672
673 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
674                                     int32_t **dc_val_ptr)
675 {
676     int i;
677
678     if (n < 4) {
679         i= 0;
680     } else {
681         i= n-3;
682     }
683     
684     *dc_val_ptr= &s->last_dc[i];
685     return s->last_dc[i]; 
686 }
687
688 static int get_dc(uint8_t *src, int stride, int scale)
689 {
690     int y;
691     int sum=0;
692     for(y=0; y<8; y++){
693         int x;
694         for(x=0; x<8; x++){
695             sum+=src[x + y*stride];
696         }
697     }
698     return FASTDIV((sum + (scale>>1)), scale);
699 }
700
701 /* dir = 0: left, dir = 1: top prediction */
702 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
703                              uint16_t **dc_val_ptr, int *dir_ptr)
704 {
705     int a, b, c, wrap, pred, scale;
706     int16_t *dc_val;
707
708     /* find prediction */
709     if (n < 4) {
710         scale = s->y_dc_scale;
711     } else {
712         scale = s->c_dc_scale;
713     }
714     
715     wrap = s->block_wrap[n];
716     dc_val= s->dc_val[0] + s->block_index[n];
717
718     /* B C
719      * A X 
720      */
721     a = dc_val[ - 1];
722     b = dc_val[ - 1 - wrap];
723     c = dc_val[ - wrap];
724     
725     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
726         b=c=1024;
727     }
728
729     /* XXX: the following solution consumes divisions, but it does not
730        necessitate to modify mpegvideo.c. The problem comes from the
731        fact they decided to store the quantized DC (which would lead
732        to problems if Q could vary !) */
733 #if defined ARCH_X86 && !defined PIC
734     asm volatile(
735         "movl %3, %%eax         \n\t"
736         "shrl $1, %%eax         \n\t"
737         "addl %%eax, %2         \n\t"
738         "addl %%eax, %1         \n\t"
739         "addl %0, %%eax         \n\t"
740         "mull %4                \n\t"
741         "movl %%edx, %0         \n\t"
742         "movl %1, %%eax         \n\t"
743         "mull %4                \n\t"
744         "movl %%edx, %1         \n\t"
745         "movl %2, %%eax         \n\t"
746         "mull %4                \n\t"
747         "movl %%edx, %2         \n\t"
748         : "+b" (a), "+c" (b), "+D" (c)
749         : "g" (scale), "S" (inverse[scale])
750         : "%eax", "%edx"
751     );
752 #else
753     /* #elif defined (ARCH_ALPHA) */
754     /* Divisions are extremely costly on Alpha; optimize the most
755        common case. But they are costly everywhere...
756      */
757     if (scale == 8) {
758         a = (a + (8 >> 1)) / 8;
759         b = (b + (8 >> 1)) / 8;
760         c = (c + (8 >> 1)) / 8;
761     } else {
762         a = FASTDIV((a + (scale >> 1)), scale);
763         b = FASTDIV((b + (scale >> 1)), scale);
764         c = FASTDIV((c + (scale >> 1)), scale);
765     }
766 #endif
767     /* XXX: WARNING: they did not choose the same test as MPEG4. This
768        is very important ! */
769     if(s->msmpeg4_version>3){
770         if(s->inter_intra_pred){
771             uint8_t *dest;
772             int wrap;
773             
774             if(n==1){
775                 pred=a;
776                 *dir_ptr = 0;
777             }else if(n==2){
778                 pred=c;
779                 *dir_ptr = 1;
780             }else if(n==3){
781                 if (abs(a - b) < abs(b - c)) {
782                     pred = c;
783                     *dir_ptr = 1;
784                 } else {
785                     pred = a;
786                     *dir_ptr = 0;
787                 }
788             }else{
789                 if(n<4){
790                     wrap= s->linesize;
791                     dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
792                 }else{
793                     wrap= s->uvlinesize;
794                     dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
795                 }
796                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
797                 else           a= get_dc(dest-8, wrap, scale*8);
798                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
799                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
800                 
801                 if (s->h263_aic_dir==0) {
802                     pred= a;
803                     *dir_ptr = 0;
804                 }else if (s->h263_aic_dir==1) {
805                     if(n==0){
806                         pred= c;
807                         *dir_ptr = 1;
808                     }else{
809                         pred= a;
810                         *dir_ptr = 0;
811                     }
812                 }else if (s->h263_aic_dir==2) {
813                     if(n==0){
814                         pred= a;
815                         *dir_ptr = 0;
816                     }else{
817                         pred= c;
818                         *dir_ptr = 1;
819                     }
820                 } else {
821                     pred= c;
822                     *dir_ptr = 1;
823                 }
824             }
825         }else{
826             if (abs(a - b) < abs(b - c)) {
827                 pred = c;
828                 *dir_ptr = 1;
829             } else {
830                 pred = a;
831                 *dir_ptr = 0;
832             }
833         }
834     }else{
835         if (abs(a - b) <= abs(b - c)) {
836             pred = c;
837             *dir_ptr = 1;
838         } else {
839             pred = a;
840             *dir_ptr = 0;
841         }
842     }
843
844     /* update predictor */
845     *dc_val_ptr = &dc_val[0];
846     return pred;
847 }
848
849 #define DC_MAX 119
850
851 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
852 {
853     int sign, code;
854     int pred;
855
856     if(s->msmpeg4_version==1){
857         int32_t *dc_val;
858         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
859         
860         /* update predictor */
861         *dc_val= level;
862     }else{
863         uint16_t *dc_val;
864         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
865
866         /* update predictor */
867         if (n < 4) {
868             *dc_val = level * s->y_dc_scale;
869         } else {
870             *dc_val = level * s->c_dc_scale;
871         }
872     }
873
874     /* do the prediction */
875     level -= pred;
876
877     if(s->msmpeg4_version<=2){
878         if (n < 4) {
879             put_bits(&s->pb, 
880                      v2_dc_lum_table[level+256][1],
881                      v2_dc_lum_table[level+256][0]);
882         }else{
883             put_bits(&s->pb, 
884                      v2_dc_chroma_table[level+256][1],
885                      v2_dc_chroma_table[level+256][0]);
886         }
887     }else{
888         sign = 0;
889         if (level < 0) {
890             level = -level;
891             sign = 1;
892         }
893         code = level;
894         if (code > DC_MAX) 
895             code = DC_MAX;
896
897         if (s->dc_table_index == 0) {
898             if (n < 4) {
899                 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
900             } else {
901                 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
902             }
903         } else {
904             if (n < 4) {
905                 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
906             } else {
907                 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
908             }
909         }
910             
911         if (code == DC_MAX)
912             put_bits(&s->pb, 8, level);
913             
914         if (level != 0) {
915             put_bits(&s->pb, 1, sign);
916         }
917     }
918 }
919
920 /* Encoding of a block. Very similar to MPEG4 except for a different
921    escape coding (same as H263) and more vlc tables.
922  */
923 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
924 {
925     int level, run, last, i, j, last_index;
926     int last_non_zero, sign, slevel;
927     int code, run_diff, dc_pred_dir;
928     const RLTable *rl;
929     const uint8_t *scantable;
930
931     if (s->mb_intra) {
932         set_stat(ST_DC);
933         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
934         i = 1;
935         if (n < 4) {
936             rl = &rl_table[s->rl_table_index];
937         } else {
938             rl = &rl_table[3 + s->rl_chroma_table_index];
939         }
940         run_diff = 0;
941         scantable= s->intra_scantable.permutated;
942         set_stat(ST_INTRA_AC);
943     } else {
944         i = 0;
945         rl = &rl_table[3 + s->rl_table_index];
946         if(s->msmpeg4_version<=2)
947             run_diff = 0;
948         else
949             run_diff = 1;
950         scantable= s->inter_scantable.permutated;
951         set_stat(ST_INTER_AC);
952     }
953
954     /* recalculate block_last_index for M$ wmv1 */
955     if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
956         for(last_index=63; last_index>=0; last_index--){
957             if(block[scantable[last_index]]) break;
958         }
959         s->block_last_index[n]= last_index;
960     }else
961         last_index = s->block_last_index[n];
962     /* AC coefs */
963     last_non_zero = i - 1;
964     for (; i <= last_index; i++) {
965         j = scantable[i];
966         level = block[j];
967         if (level) {
968             run = i - last_non_zero - 1;
969             last = (i == last_index);
970             sign = 0;
971             slevel = level;
972             if (level < 0) {
973                 sign = 1;
974                 level = -level;
975             }
976
977             if(level<=MAX_LEVEL && run<=MAX_RUN){
978                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
979             }
980 #if 0
981 else
982     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
983 #endif
984             code = get_rl_index(rl, last, run, level);
985             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986             if (code == rl->n) {
987                 int level1, run1;
988
989                 level1 = level - rl->max_level[last][run];
990                 if (level1 < 1) 
991                     goto esc2;
992                 code = get_rl_index(rl, last, run, level1);
993                 if (code == rl->n) {
994                 esc2:
995                     put_bits(&s->pb, 1, 0);
996                     if (level > MAX_LEVEL)
997                         goto esc3;
998                     run1 = run - rl->max_run[last][level] - run_diff;
999                     if (run1 < 0)
1000                         goto esc3;
1001                     code = get_rl_index(rl, last, run1, level);
1002                     if (code == rl->n) {
1003                     esc3:
1004                         /* third escape */
1005                         put_bits(&s->pb, 1, 0);
1006                         put_bits(&s->pb, 1, last);
1007                         if(s->msmpeg4_version>=4){
1008                             if(s->esc3_level_length==0){
1009                                 s->esc3_level_length=8;
1010                                 s->esc3_run_length= 6;
1011                                 if(s->qscale<8)
1012                                     put_bits(&s->pb, 6, 3);
1013                                 else
1014                                     put_bits(&s->pb, 8, 3);
1015                             }
1016                             put_bits(&s->pb, s->esc3_run_length, run);
1017                             put_bits(&s->pb, 1, sign);
1018                             put_bits(&s->pb, s->esc3_level_length, level);
1019                         }else{
1020                             put_bits(&s->pb, 6, run);
1021                             put_bits(&s->pb, 8, slevel & 0xff);
1022                         }
1023                     } else {
1024                         /* second escape */
1025                         put_bits(&s->pb, 1, 1);
1026                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1027                         put_bits(&s->pb, 1, sign);
1028                     }
1029                 } else {
1030                     /* first escape */
1031                     put_bits(&s->pb, 1, 1);
1032                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1033                     put_bits(&s->pb, 1, sign);
1034                 }
1035             } else {
1036                 put_bits(&s->pb, 1, sign);
1037             }
1038             last_non_zero = i;
1039         }
1040     }
1041 }
1042
1043 /****************************************/
1044 /* decoding stuff */
1045
1046 static VLC mb_non_intra_vlc[4];
1047 static VLC mb_intra_vlc;
1048 static VLC dc_lum_vlc[2];
1049 static VLC dc_chroma_vlc[2];
1050 static VLC v2_dc_lum_vlc;
1051 static VLC v2_dc_chroma_vlc;
1052 static VLC cbpy_vlc;
1053 static VLC v2_intra_cbpc_vlc;
1054 static VLC v2_mb_type_vlc;
1055 static VLC v2_mv_vlc;
1056 static VLC v1_intra_cbpc_vlc;
1057 static VLC v1_inter_cbpc_vlc;
1058 static VLC inter_intra_vlc;
1059
1060 /* this table is practically identical to the one from h263 except that its inverted */
1061 static void init_h263_dc_for_msmpeg4(void)
1062 {
1063         int level, uni_code, uni_len;
1064
1065         for(level=-256; level<256; level++){
1066             int size, v, l;
1067             /* find number of bits */
1068             size = 0;
1069             v = abs(level);
1070             while (v) {
1071                 v >>= 1;
1072                     size++;
1073             }
1074
1075             if (level < 0)
1076                 l= (-level) ^ ((1 << size) - 1);
1077             else
1078                 l= level;
1079
1080             /* luminance h263 */
1081             uni_code= DCtab_lum[size][0];
1082             uni_len = DCtab_lum[size][1];
1083             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1084
1085             if (size > 0) {
1086                 uni_code<<=size; uni_code|=l;
1087                 uni_len+=size;
1088                 if (size > 8){
1089                     uni_code<<=1; uni_code|=1;
1090                     uni_len++;
1091                 }
1092             }
1093             v2_dc_lum_table[level+256][0]= uni_code;
1094             v2_dc_lum_table[level+256][1]= uni_len;
1095
1096             /* chrominance h263 */
1097             uni_code= DCtab_chrom[size][0];
1098             uni_len = DCtab_chrom[size][1];
1099             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1100             
1101             if (size > 0) {
1102                 uni_code<<=size; uni_code|=l;
1103                 uni_len+=size;
1104                 if (size > 8){
1105                     uni_code<<=1; uni_code|=1;
1106                     uni_len++;
1107                 }
1108             }
1109             v2_dc_chroma_table[level+256][0]= uni_code;
1110             v2_dc_chroma_table[level+256][1]= uni_len;
1111
1112         }
1113 }
1114
1115 /* init all vlc decoding tables */
1116 int ff_msmpeg4_decode_init(MpegEncContext *s)
1117 {
1118     static int done = 0;
1119     int i;
1120     MVTable *mv;
1121
1122     common_init(s);
1123
1124     if (!done) {
1125         done = 1;
1126
1127         for(i=0;i<NB_RL_TABLES;i++) {
1128             init_rl(&rl_table[i]);
1129             init_vlc_rl(&rl_table[i]);
1130         }
1131         for(i=0;i<2;i++) {
1132             mv = &mv_tables[i];
1133             init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, 
1134                      mv->table_mv_bits, 1, 1,
1135                      mv->table_mv_code, 2, 2);
1136         }
1137
1138         init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 
1139                  &table0_dc_lum[0][1], 8, 4,
1140                  &table0_dc_lum[0][0], 8, 4);
1141         init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1142                  &table0_dc_chroma[0][1], 8, 4,
1143                  &table0_dc_chroma[0][0], 8, 4);
1144         init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 
1145                  &table1_dc_lum[0][1], 8, 4,
1146                  &table1_dc_lum[0][0], 8, 4);
1147         init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1148                  &table1_dc_chroma[0][1], 8, 4,
1149                  &table1_dc_chroma[0][0], 8, 4);
1150     
1151         init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 
1152                  &v2_dc_lum_table[0][1], 8, 4,
1153                  &v2_dc_lum_table[0][0], 8, 4);
1154         init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 
1155                  &v2_dc_chroma_table[0][1], 8, 4,
1156                  &v2_dc_chroma_table[0][0], 8, 4);
1157     
1158         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1159                  &cbpy_tab[0][1], 2, 1,
1160                  &cbpy_tab[0][0], 2, 1);
1161         init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1162                  &v2_intra_cbpc[0][1], 2, 1,
1163                  &v2_intra_cbpc[0][0], 2, 1);
1164         init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1165                  &v2_mb_type[0][1], 2, 1,
1166                  &v2_mb_type[0][0], 2, 1);
1167         init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1168                  &mvtab[0][1], 2, 1,
1169                  &mvtab[0][0], 2, 1);
1170
1171         for(i=0; i<4; i++){
1172             init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, 
1173                      &wmv2_inter_table[i][0][1], 8, 4,
1174                      &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1175         }
1176         
1177         init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64, 
1178                  &table_mb_intra[0][1], 4, 2,
1179                  &table_mb_intra[0][0], 4, 2);
1180         
1181         init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, 
1182                  intra_MCBPC_bits, 1, 1,
1183                  intra_MCBPC_code, 1, 1);
1184         init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25, 
1185                  inter_MCBPC_bits, 1, 1,
1186                  inter_MCBPC_code, 1, 1);
1187         
1188         init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 
1189                  &table_inter_intra[0][1], 2, 1,
1190                  &table_inter_intra[0][0], 2, 1);
1191     }
1192     
1193     switch(s->msmpeg4_version){
1194     case 1:
1195     case 2:
1196         s->decode_mb= msmpeg4v12_decode_mb;
1197         break;
1198     case 3:
1199     case 4:
1200         s->decode_mb= msmpeg4v34_decode_mb;
1201         break;
1202     case 5:
1203         s->decode_mb= wmv2_decode_mb;
1204         break;
1205     }
1206     
1207     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1208     
1209     return 0;
1210 }
1211
1212 static int decode012(GetBitContext *gb)
1213 {
1214     int n;
1215     n = get_bits1(gb);
1216     if (n == 0)
1217         return 0;
1218     else
1219         return get_bits1(gb) + 1;
1220 }
1221
1222 int msmpeg4_decode_picture_header(MpegEncContext * s)
1223 {
1224     int code;
1225
1226 #if 0
1227 {
1228 int i;
1229 for(i=0; i<s->gb.size_in_bits; i++)
1230     printf("%d", get_bits1(&s->gb));
1231 //    get_bits1(&s->gb);
1232 printf("END\n");
1233 return -1;
1234 }
1235 #endif
1236
1237     if(s->msmpeg4_version==1){
1238         int start_code, num;
1239         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1240         if(start_code!=0x00000100){
1241             fprintf(stderr, "invalid startcode\n");
1242             return -1;
1243         }
1244
1245         num= get_bits(&s->gb, 5); // frame number */
1246     }
1247
1248     s->pict_type = get_bits(&s->gb, 2) + 1;
1249     if (s->pict_type != I_TYPE &&
1250         s->pict_type != P_TYPE){
1251         fprintf(stderr, "invalid picture type\n");
1252         return -1;
1253     }
1254 #if 0
1255 {
1256     static int had_i=0;
1257     if(s->pict_type == I_TYPE) had_i=1;
1258     if(!had_i) return -1;
1259 }
1260 #endif
1261     s->qscale = get_bits(&s->gb, 5);
1262     if(s->qscale==0){
1263         fprintf(stderr, "invalid qscale\n");
1264         return -1;
1265     }
1266
1267     if (s->pict_type == I_TYPE) {
1268         code = get_bits(&s->gb, 5); 
1269         if(s->msmpeg4_version==1){
1270             if(code==0 || code>s->mb_height){
1271                 fprintf(stderr, "invalid slice height %d\n", code);
1272                 return -1;
1273             }
1274
1275             s->slice_height = code;
1276         }else{
1277             /* 0x17: one slice, 0x18: two slices, ... */
1278             if (code < 0x17){
1279                 fprintf(stderr, "error, slice code was %X\n", code);
1280                 return -1;
1281             }
1282
1283             s->slice_height = s->mb_height / (code - 0x16);
1284         }
1285
1286         switch(s->msmpeg4_version){
1287         case 1:
1288         case 2:
1289             s->rl_chroma_table_index = 2;
1290             s->rl_table_index = 2;
1291
1292             s->dc_table_index = 0; //not used
1293             break;
1294         case 3:
1295             s->rl_chroma_table_index = decode012(&s->gb);
1296             s->rl_table_index = decode012(&s->gb);
1297
1298             s->dc_table_index = get_bits1(&s->gb);
1299             break;
1300         case 4:
1301             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1302
1303             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1304             else                           s->per_mb_rl_table= 0;
1305             
1306             if(!s->per_mb_rl_table){
1307                 s->rl_chroma_table_index = decode012(&s->gb);
1308                 s->rl_table_index = decode012(&s->gb);
1309             }
1310
1311             s->dc_table_index = get_bits1(&s->gb);
1312             s->inter_intra_pred= 0;
1313             break;
1314         }
1315         s->no_rounding = 1;
1316 /*      printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n", 
1317                 s->qscale,
1318                 s->rl_chroma_table_index,
1319                 s->rl_table_index, 
1320                 s->dc_table_index,
1321                 s->per_mb_rl_table,
1322                 s->slice_height);*/
1323     } else {
1324         switch(s->msmpeg4_version){
1325         case 1:
1326         case 2:
1327             if(s->msmpeg4_version==1)
1328                 s->use_skip_mb_code = 1;
1329             else
1330                 s->use_skip_mb_code = get_bits1(&s->gb);
1331             s->rl_table_index = 2;
1332             s->rl_chroma_table_index = s->rl_table_index;
1333             s->dc_table_index = 0; //not used
1334             s->mv_table_index = 0;
1335             break;
1336         case 3:
1337             s->use_skip_mb_code = get_bits1(&s->gb);
1338             s->rl_table_index = decode012(&s->gb);
1339             s->rl_chroma_table_index = s->rl_table_index;
1340
1341             s->dc_table_index = get_bits1(&s->gb);
1342
1343             s->mv_table_index = get_bits1(&s->gb);
1344             break;
1345         case 4:
1346             s->use_skip_mb_code = get_bits1(&s->gb);
1347
1348             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1349             else                           s->per_mb_rl_table= 0;
1350
1351             if(!s->per_mb_rl_table){
1352                 s->rl_table_index = decode012(&s->gb);
1353                 s->rl_chroma_table_index = s->rl_table_index;
1354             }
1355
1356             s->dc_table_index = get_bits1(&s->gb);
1357
1358             s->mv_table_index = get_bits1(&s->gb);
1359             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1360             break;
1361         }
1362 /*      printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n", 
1363                 s->use_skip_mb_code, 
1364                 s->rl_table_index, 
1365                 s->rl_chroma_table_index, 
1366                 s->dc_table_index,
1367                 s->mv_table_index,
1368                 s->per_mb_rl_table,
1369                 s->qscale);*/
1370         if(s->flipflop_rounding){
1371             s->no_rounding ^= 1;
1372         }else{
1373             s->no_rounding = 0;
1374         }
1375     }
1376 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1377
1378     s->esc3_level_length= 0;
1379     s->esc3_run_length= 0;
1380
1381 #ifdef DEBUG
1382     printf("*****frame %d:\n", frame_count++);
1383 #endif
1384     return 0;
1385 }
1386
1387 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1388 {
1389     int left= buf_size*8 - get_bits_count(&s->gb);
1390     int length= s->msmpeg4_version>=3 ? 17 : 16;
1391     /* the alt_bitstream reader could read over the end so we need to check it */
1392     if(left>=length && left<length+8)
1393     {
1394         int fps;
1395
1396         fps= get_bits(&s->gb, 5);
1397         s->bit_rate= get_bits(&s->gb, 11)*1024;
1398         if(s->msmpeg4_version>=3)
1399             s->flipflop_rounding= get_bits1(&s->gb);
1400         else
1401             s->flipflop_rounding= 0;
1402
1403 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1404     }
1405     else if(left<length+8)
1406     {
1407         s->flipflop_rounding= 0;
1408         printf("ext header missing, %d left\n", left);
1409     }
1410     else
1411     {
1412         fprintf(stderr, "I frame too long, ignoring ext header\n");
1413     }
1414
1415     return 0;
1416 }
1417
1418 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1419 {
1420     int i;
1421     for(i=0;i<n;i++)
1422         tab[i] = val;
1423 }
1424
1425 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1426 {
1427     int range, bit_size, sign, code, bits;
1428
1429     if (val == 0) {
1430         /* zero vector */
1431         code = 0;
1432         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1433     } else {
1434         bit_size = s->f_code - 1;
1435         range = 1 << bit_size;
1436         if (val <= -64)
1437             val += 64;
1438         else if (val >= 64)
1439             val -= 64;
1440
1441         if (val >= 0) {
1442             sign = 0;
1443         } else {
1444             val = -val;
1445             sign = 1;
1446         }
1447         val--;
1448         code = (val >> bit_size) + 1;
1449         bits = val & (range - 1);
1450
1451         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1452         if (bit_size > 0) {
1453             put_bits(&s->pb, bit_size, bits);
1454         }
1455     }
1456 }
1457
1458 /* this is identical to h263 except that its range is multiplied by 2 */
1459 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1460 {
1461     int code, val, sign, shift;
1462
1463     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1464 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1465     if (code < 0)
1466         return 0xffff;
1467
1468     if (code == 0)
1469         return pred;
1470     sign = get_bits1(&s->gb);
1471     shift = f_code - 1;
1472     val = code;
1473     if (shift) {
1474         val = (val - 1) << shift;
1475         val |= get_bits(&s->gb, shift);
1476         val++;
1477     }
1478     if (sign)
1479         val = -val;
1480
1481     val += pred;
1482     if (val <= -64)
1483         val += 64;
1484     else if (val >= 64)
1485         val -= 64;
1486
1487     return val;
1488 }
1489
1490 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1491 {
1492     int cbp, code, i;
1493     
1494     if (s->pict_type == P_TYPE) {
1495         if (s->use_skip_mb_code) {
1496             if (get_bits1(&s->gb)) {
1497                 /* skip mb */
1498                 s->mb_intra = 0;
1499                 for(i=0;i<6;i++)
1500                     s->block_last_index[i] = -1;
1501                 s->mv_dir = MV_DIR_FORWARD;
1502                 s->mv_type = MV_TYPE_16X16;
1503                 s->mv[0][0][0] = 0;
1504                 s->mv[0][0][1] = 0;
1505                 s->mb_skiped = 1;
1506                 return 0;
1507             }
1508         }
1509
1510         if(s->msmpeg4_version==2)
1511             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1512         else
1513             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1514         if(code<0 || code>7){
1515             fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1516             return -1;
1517         }
1518
1519         s->mb_intra = code >>2;
1520     
1521         cbp = code & 0x3;
1522     } else {
1523         s->mb_intra = 1;
1524         if(s->msmpeg4_version==2)
1525             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1526         else
1527             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1528         if(cbp<0 || cbp>3){
1529             fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1530             return -1;
1531         }
1532     }
1533
1534     if (!s->mb_intra) {
1535         int mx, my, cbpy;
1536         
1537         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1538         if(cbpy<0){
1539             fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1540             return -1;
1541         }
1542
1543         cbp|= cbpy<<2;
1544         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1545         
1546         h263_pred_motion(s, 0, &mx, &my);
1547         mx= msmpeg4v2_decode_motion(s, mx, 1);
1548         my= msmpeg4v2_decode_motion(s, my, 1);
1549         
1550         s->mv_dir = MV_DIR_FORWARD;
1551         s->mv_type = MV_TYPE_16X16;
1552         s->mv[0][0][0] = mx;
1553         s->mv[0][0][1] = my;
1554     } else {
1555         if(s->msmpeg4_version==2){
1556             s->ac_pred = get_bits1(&s->gb);
1557             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1558         } else{
1559             s->ac_pred = 0;
1560             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1561             if(s->pict_type==P_TYPE) cbp^=0x3C;
1562         }
1563     }
1564
1565     for (i = 0; i < 6; i++) {
1566         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1567         {
1568              fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1569              return -1;
1570         }
1571     }
1572     return 0;
1573 }
1574
1575 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1576 {
1577     int cbp, code, i;
1578     uint8_t *coded_val;
1579     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1580
1581     if (s->pict_type == P_TYPE) {
1582         set_stat(ST_INTER_MB);
1583         if (s->use_skip_mb_code) {
1584             if (get_bits1(&s->gb)) {
1585                 /* skip mb */
1586                 s->mb_intra = 0;
1587                 for(i=0;i<6;i++)
1588                     s->block_last_index[i] = -1;
1589                 s->mv_dir = MV_DIR_FORWARD;
1590                 s->mv_type = MV_TYPE_16X16;
1591                 s->mv[0][0][0] = 0;
1592                 s->mv[0][0][1] = 0;
1593                 s->mb_skiped = 1;
1594                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1595
1596                 return 0;
1597             }
1598         }
1599         
1600         code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1601         if (code < 0)
1602             return -1;
1603         //s->mb_intra = (code & 0x40) ? 0 : 1;
1604         s->mb_intra = (~code & 0x40) >> 6;
1605             
1606         cbp = code & 0x3f;
1607     } else {
1608         set_stat(ST_INTRA_MB);
1609         s->mb_intra = 1;
1610         code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1611         if (code < 0)
1612             return -1;
1613         /* predict coded block pattern */
1614         cbp = 0;
1615         for(i=0;i<6;i++) {
1616             int val = ((code >> (5 - i)) & 1);
1617             if (i < 4) {
1618                 int pred = coded_block_pred(s, i, &coded_val);
1619                 val = val ^ pred;
1620                 *coded_val = val;
1621             }
1622             cbp |= val << (5 - i);
1623         }
1624     }
1625
1626     if (!s->mb_intra) {
1627         int mx, my;
1628 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1629         if(s->per_mb_rl_table && cbp){
1630             s->rl_table_index = decode012(&s->gb);
1631             s->rl_chroma_table_index = s->rl_table_index;
1632         }
1633         set_stat(ST_MV);
1634         h263_pred_motion(s, 0, &mx, &my);
1635         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1636             return -1;
1637         s->mv_dir = MV_DIR_FORWARD;
1638         s->mv_type = MV_TYPE_16X16;
1639         s->mv[0][0][0] = mx;
1640         s->mv[0][0][1] = my;
1641         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1642     } else {
1643 //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));
1644         set_stat(ST_INTRA_MB);
1645         s->ac_pred = get_bits1(&s->gb);
1646         *mb_type_ptr = MB_TYPE_INTRA;
1647         if(s->inter_intra_pred){
1648             s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1649 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1650         }
1651         if(s->per_mb_rl_table && cbp){
1652             s->rl_table_index = decode012(&s->gb);
1653             s->rl_chroma_table_index = s->rl_table_index;
1654         }
1655     }
1656
1657     for (i = 0; i < 6; i++) {
1658         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1659         {
1660             fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1661             return -1;
1662         }
1663     }
1664     
1665     return 0;
1666 }
1667 //#define ERROR_DETAILS
1668 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1669                               int n, int coded, const uint8_t *scan_table)
1670 {
1671     int level, i, last, run, run_diff;
1672     int dc_pred_dir;
1673     RLTable *rl;
1674     RL_VLC_ELEM *rl_vlc;
1675     int qmul, qadd;
1676
1677     if (s->mb_intra) {
1678         qmul=1;
1679         qadd=0;
1680
1681         /* DC coef */
1682         set_stat(ST_DC);
1683         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1684         
1685         if (level < 0){
1686             fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1687             if(s->inter_intra_pred) level=0;
1688             else                    return -1;
1689         }
1690         if (n < 4) {
1691             rl = &rl_table[s->rl_table_index];
1692             if(level > 256*s->y_dc_scale){
1693                 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1694                 if(!s->inter_intra_pred) return -1;
1695             }
1696         } else {
1697             rl = &rl_table[3 + s->rl_chroma_table_index];
1698             if(level > 256*s->c_dc_scale){
1699                 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1700                 if(!s->inter_intra_pred) return -1;
1701             }
1702         }
1703         block[0] = level;
1704
1705         run_diff = 0;
1706         i = 0;
1707         if (!coded) {
1708             goto not_coded;
1709         }
1710         if (s->ac_pred) {
1711             if (dc_pred_dir == 0) 
1712                 scan_table = s->intra_v_scantable.permutated; /* left */
1713             else
1714                 scan_table = s->intra_h_scantable.permutated; /* top */
1715         } else {
1716             scan_table = s->intra_scantable.permutated;
1717         }
1718         set_stat(ST_INTRA_AC);
1719         rl_vlc= rl->rl_vlc[0];
1720     } else {
1721         qmul = s->qscale << 1;
1722         qadd = (s->qscale - 1) | 1;
1723         i = -1;
1724         rl = &rl_table[3 + s->rl_table_index];
1725
1726         if(s->msmpeg4_version==2)
1727             run_diff = 0;
1728         else
1729             run_diff = 1;
1730
1731         if (!coded) {
1732             s->block_last_index[n] = i;
1733             return 0;
1734         }
1735         if(!scan_table)
1736             scan_table = s->inter_scantable.permutated;
1737         set_stat(ST_INTER_AC);
1738         rl_vlc= rl->rl_vlc[s->qscale];
1739     }
1740   {
1741     OPEN_READER(re, &s->gb);
1742     for(;;) {
1743         UPDATE_CACHE(re, &s->gb);
1744         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1745         if (level==0) {
1746             int cache;
1747             cache= GET_CACHE(re, &s->gb);
1748             /* escape */
1749             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1750                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1751                     /* third escape */
1752                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1753                     UPDATE_CACHE(re, &s->gb);
1754                     if(s->msmpeg4_version<=3){
1755                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1756                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1757                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1758                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1759                     }else{                        
1760                         int sign;
1761                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1762                         if(!s->esc3_level_length){
1763                             int ll;
1764                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1765                             if(s->qscale<8){
1766                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1767                                 if(ll==0){
1768                                     if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1769                                     SKIP_BITS(re, &s->gb, 1);
1770                                     ll=8;
1771                                 }
1772                             }else{
1773                                 ll=2;
1774                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1775                                     ll++;
1776                                     SKIP_BITS(re, &s->gb, 1);
1777                                 }
1778                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1779                             }
1780
1781                             s->esc3_level_length= ll;
1782                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1783 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1784                             UPDATE_CACHE(re, &s->gb);
1785                         }
1786                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length); 
1787                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1788                         
1789                         sign=  SHOW_UBITS(re, &s->gb, 1); 
1790                         SKIP_BITS(re, &s->gb, 1);
1791                         
1792                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); 
1793                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1794                         if(sign) level= -level;
1795                     }
1796 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1797 #if 0 // waste of time / this will detect very few errors
1798                     {
1799                         const int abs_level= ABS(level);
1800                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1801                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1802                             if(abs_level <= rl->max_level[last][run]){
1803                                 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1804                                 return DECODING_AC_LOST;
1805                             }
1806                             if(abs_level <= rl->max_level[last][run]*2){
1807                                 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1808                                 return DECODING_AC_LOST;
1809                             }
1810                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1811                                 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1812                                 return DECODING_AC_LOST;
1813                             }
1814                         }
1815                     }
1816 #endif
1817                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1818                     if (level>0) level= level * qmul + qadd;
1819                     else         level= level * qmul - qadd;
1820 #if 0 // waste of time too :(
1821                     if(level>2048 || level<-2048){
1822                         fprintf(stderr, "|level| overflow in 3. esc\n");
1823                         return DECODING_AC_LOST;
1824                     }
1825 #endif
1826                     i+= run + 1;
1827                     if(last) i+=192;
1828 #ifdef ERROR_DETAILS
1829                 if(run==66)
1830                     fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1831                 else if((i>62 && i<192) || i>192+63)
1832                     fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1833 #endif
1834                 } else {
1835                     /* second escape */
1836 #if MIN_CACHE_BITS < 23
1837                     LAST_SKIP_BITS(re, &s->gb, 2);
1838                     UPDATE_CACHE(re, &s->gb);
1839 #else
1840                     SKIP_BITS(re, &s->gb, 2);
1841 #endif
1842                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1843                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1844                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1845                     LAST_SKIP_BITS(re, &s->gb, 1);
1846 #ifdef ERROR_DETAILS
1847                 if(run==66)
1848                     fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1849                 else if((i>62 && i<192) || i>192+63)
1850                     fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1851 #endif
1852                 }
1853             } else {
1854                 /* first escape */
1855 #if MIN_CACHE_BITS < 22
1856                 LAST_SKIP_BITS(re, &s->gb, 1);
1857                 UPDATE_CACHE(re, &s->gb);
1858 #else
1859                 SKIP_BITS(re, &s->gb, 1);
1860 #endif
1861                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1862                 i+= run;
1863                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1864                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1865                 LAST_SKIP_BITS(re, &s->gb, 1);
1866 #ifdef ERROR_DETAILS
1867                 if(run==66)
1868                     fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1869                 else if((i>62 && i<192) || i>192+63)
1870                     fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1871 #endif
1872             }
1873         } else {
1874             i+= run;
1875             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1876             LAST_SKIP_BITS(re, &s->gb, 1);
1877 #ifdef ERROR_DETAILS
1878                 if(run==66)
1879                     fprintf(stderr, "illegal vlc code level=%d\n", level);
1880                 else if((i>62 && i<192) || i>192+63)
1881                     fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1882 #endif
1883         }
1884         if (i > 62){
1885             i-= 192;
1886             if(i&(~63)){
1887                 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1888                 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1889                     fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1890                     break;
1891                 }else{
1892                     fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1893                     return -1;
1894                 }
1895             }
1896
1897             block[scan_table[i]] = level;
1898             break;
1899         }
1900
1901         block[scan_table[i]] = level;
1902     }
1903     CLOSE_READER(re, &s->gb);
1904   }
1905  not_coded:
1906     if (s->mb_intra) {
1907         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1908         if (s->ac_pred) {
1909             i = 63; /* XXX: not optimal */
1910         }
1911     }
1912     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1913     s->block_last_index[n] = i;
1914     
1915     return 0;
1916 }
1917
1918 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1919 {
1920     int level, pred;
1921
1922     if(s->msmpeg4_version<=2){
1923         if (n < 4) {
1924             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1925         } else {
1926             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1927         }
1928         if (level < 0) 
1929             return -1;
1930         level-=256;
1931     }else{  //FIXME optimize use unified tables & index
1932         if (n < 4) {
1933             level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1934         } else {
1935             level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1936         }
1937         if (level < 0){
1938             fprintf(stderr, "illegal dc vlc\n");
1939             return -1;
1940         }
1941
1942         if (level == DC_MAX) {
1943             level = get_bits(&s->gb, 8);
1944             if (get_bits1(&s->gb))
1945                 level = -level;
1946         } else if (level != 0) {
1947             if (get_bits1(&s->gb))
1948                 level = -level;
1949         }
1950     }
1951
1952     if(s->msmpeg4_version==1){
1953         int32_t *dc_val;
1954         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1955         level += pred;
1956         
1957         /* update predictor */
1958         *dc_val= level;
1959     }else{
1960         uint16_t *dc_val;
1961         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1962         level += pred;
1963
1964         /* update predictor */
1965         if (n < 4) {
1966             *dc_val = level * s->y_dc_scale;
1967         } else {
1968             *dc_val = level * s->c_dc_scale;
1969         }
1970     }
1971
1972     return level;
1973 }
1974
1975 static int msmpeg4_decode_motion(MpegEncContext * s, 
1976                                  int *mx_ptr, int *my_ptr)
1977 {
1978     MVTable *mv;
1979     int code, mx, my;
1980
1981     mv = &mv_tables[s->mv_table_index];
1982
1983     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1984     if (code < 0){
1985         fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1986         return -1;
1987     }
1988     if (code == mv->n) {
1989 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1990         mx = get_bits(&s->gb, 6);
1991         my = get_bits(&s->gb, 6);
1992     } else {
1993         mx = mv->table_mvx[code];
1994         my = mv->table_mvy[code];
1995     }
1996
1997     mx += *mx_ptr - 32;
1998     my += *my_ptr - 32;
1999     /* WARNING : they do not do exactly modulo encoding */
2000     if (mx <= -64)
2001         mx += 64;
2002     else if (mx >= 64)
2003         mx -= 64;
2004
2005     if (my <= -64)
2006         my += 64;
2007     else if (my >= 64)
2008         my -= 64;
2009     *mx_ptr = mx;
2010     *my_ptr = my;
2011     return 0;
2012 }
2013
2014 /* cleanest way to support it
2015  * there is too much shared between versions so that we cant have 1 file per version & 1 common
2016  * as allmost everything would be in the common file 
2017  */
2018 #include "wmv2.c"