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