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