f21fed794643cc561c26c04eda5a8edf52b2b8c6
[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  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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 void ff_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 it is 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 void ff_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     ff_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 literally */
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             ff_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             ff_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, extquant;
787     int extrabits = 0;
788
789     if(s->msmpeg4_version==1){
790         int32_t *dc_val;
791         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
792
793         /* update predictor */
794         *dc_val= level;
795     }else{
796         int16_t *dc_val;
797         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
798
799         /* update predictor */
800         if (n < 4) {
801             *dc_val = level * s->y_dc_scale;
802         } else {
803             *dc_val = level * s->c_dc_scale;
804         }
805     }
806
807     /* do the prediction */
808     level -= pred;
809
810     if(s->msmpeg4_version<=2){
811         if (n < 4) {
812             put_bits(&s->pb,
813                      v2_dc_lum_table[level+256][1],
814                      v2_dc_lum_table[level+256][0]);
815         }else{
816             put_bits(&s->pb,
817                      v2_dc_chroma_table[level+256][1],
818                      v2_dc_chroma_table[level+256][0]);
819         }
820     }else{
821         sign = 0;
822         if (level < 0) {
823             level = -level;
824             sign = 1;
825         }
826         code = level;
827         if (code > DC_MAX)
828             code = DC_MAX;
829         else if( s->msmpeg4_version>=6 ) {
830             if( s->qscale == 1 ) {
831                 extquant = (level + 3) & 0x3;
832                 code  = ((level+3)>>2);
833             } else if( s->qscale == 2 ) {
834                 extquant = (level + 1) & 0x1;
835                 code  = ((level+1)>>1);
836             }
837         }
838
839         if (s->dc_table_index == 0) {
840             if (n < 4) {
841                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
842             } else {
843                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
844             }
845         } else {
846             if (n < 4) {
847                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
848             } else {
849                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
850             }
851         }
852
853         if(s->msmpeg4_version>=6 && s->qscale<=2)
854             extrabits = 3 - s->qscale;
855
856         if (code == DC_MAX)
857             put_bits(&s->pb, 8 + extrabits, level);
858         else if(extrabits > 0)//== VC1 && s->qscale<=2
859             put_bits(&s->pb, extrabits, extquant);
860
861         if (level != 0) {
862             put_bits(&s->pb, 1, sign);
863         }
864     }
865 }
866
867 /* Encoding of a block. Very similar to MPEG4 except for a different
868    escape coding (same as H263) and more vlc tables.
869  */
870 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
871 {
872     int level, run, last, i, j, last_index;
873     int last_non_zero, sign, slevel;
874     int code, run_diff, dc_pred_dir;
875     const RLTable *rl;
876     const uint8_t *scantable;
877
878     if (s->mb_intra) {
879         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
880         i = 1;
881         if (n < 4) {
882             rl = &rl_table[s->rl_table_index];
883         } else {
884             rl = &rl_table[3 + s->rl_chroma_table_index];
885         }
886         run_diff = s->msmpeg4_version>=4;
887         scantable= s->intra_scantable.permutated;
888     } else {
889         i = 0;
890         rl = &rl_table[3 + s->rl_table_index];
891         if(s->msmpeg4_version<=2)
892             run_diff = 0;
893         else
894             run_diff = 1;
895         scantable= s->inter_scantable.permutated;
896     }
897
898     /* recalculate block_last_index for M$ wmv1 */
899     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
900         for(last_index=63; last_index>=0; last_index--){
901             if(block[scantable[last_index]]) break;
902         }
903         s->block_last_index[n]= last_index;
904     }else
905         last_index = s->block_last_index[n];
906     /* AC coefs */
907     last_non_zero = i - 1;
908     for (; i <= last_index; i++) {
909         j = scantable[i];
910         level = block[j];
911         if (level) {
912             run = i - last_non_zero - 1;
913             last = (i == last_index);
914             sign = 0;
915             slevel = level;
916             if (level < 0) {
917                 sign = 1;
918                 level = -level;
919             }
920
921             if(level<=MAX_LEVEL && run<=MAX_RUN){
922                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
923             }
924 #if 0
925 else
926     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
927 #endif
928             code = get_rl_index(rl, last, run, level);
929             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
930             if (code == rl->n) {
931                 int level1, run1;
932
933                 level1 = level - rl->max_level[last][run];
934                 if (level1 < 1)
935                     goto esc2;
936                 code = get_rl_index(rl, last, run, level1);
937                 if (code == rl->n) {
938                 esc2:
939                     put_bits(&s->pb, 1, 0);
940                     if (level > MAX_LEVEL)
941                         goto esc3;
942                     run1 = run - rl->max_run[last][level] - run_diff;
943                     if (run1 < 0)
944                         goto esc3;
945                     code = get_rl_index(rl, last, run1+1, level);
946                     if (s->msmpeg4_version == 4 && code == rl->n)
947                         goto esc3;
948                     code = get_rl_index(rl, last, run1, level);
949                     if (code == rl->n) {
950                     esc3:
951                         /* third escape */
952                         put_bits(&s->pb, 1, 0);
953                         put_bits(&s->pb, 1, last);
954                         if(s->msmpeg4_version>=4){
955                             if(s->esc3_level_length==0){
956                                 s->esc3_level_length=8;
957                                 s->esc3_run_length= 6;
958                                 //ESCLVLSZ + ESCRUNSZ
959                                 if(s->qscale<8)
960                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
961                                 else
962                                     put_bits(&s->pb, 8, 3);
963                             }
964                             put_bits(&s->pb, s->esc3_run_length, run);
965                             put_bits(&s->pb, 1, sign);
966                             put_bits(&s->pb, s->esc3_level_length, level);
967                         }else{
968                             put_bits(&s->pb, 6, run);
969                             put_bits(&s->pb, 8, slevel & 0xff);
970                         }
971                     } else {
972                         /* second escape */
973                         put_bits(&s->pb, 1, 1);
974                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
975                         put_bits(&s->pb, 1, sign);
976                     }
977                 } else {
978                     /* first escape */
979                     put_bits(&s->pb, 1, 1);
980                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
981                     put_bits(&s->pb, 1, sign);
982                 }
983             } else {
984                 put_bits(&s->pb, 1, sign);
985             }
986             last_non_zero = i;
987         }
988     }
989 }
990
991 /****************************************/
992 /* decoding stuff */
993
994 static VLC mb_non_intra_vlc[4];
995 static VLC v2_dc_lum_vlc;
996 static VLC v2_dc_chroma_vlc;
997 static VLC cbpy_vlc;
998 static VLC v2_intra_cbpc_vlc;
999 static VLC v2_mb_type_vlc;
1000 static VLC v2_mv_vlc;
1001 static VLC v1_intra_cbpc_vlc;
1002 static VLC v1_inter_cbpc_vlc;
1003 static VLC inter_intra_vlc;
1004
1005 /* This table is practically identical to the one from h263
1006  * except that it is inverted. */
1007 static void init_h263_dc_for_msmpeg4(void)
1008 {
1009         int level, uni_code, uni_len;
1010
1011         for(level=-256; level<256; level++){
1012             int size, v, l;
1013             /* find number of bits */
1014             size = 0;
1015             v = abs(level);
1016             while (v) {
1017                 v >>= 1;
1018                     size++;
1019             }
1020
1021             if (level < 0)
1022                 l= (-level) ^ ((1 << size) - 1);
1023             else
1024                 l= level;
1025
1026             /* luminance h263 */
1027             uni_code= DCtab_lum[size][0];
1028             uni_len = DCtab_lum[size][1];
1029             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1030
1031             if (size > 0) {
1032                 uni_code<<=size; uni_code|=l;
1033                 uni_len+=size;
1034                 if (size > 8){
1035                     uni_code<<=1; uni_code|=1;
1036                     uni_len++;
1037                 }
1038             }
1039             v2_dc_lum_table[level+256][0]= uni_code;
1040             v2_dc_lum_table[level+256][1]= uni_len;
1041
1042             /* chrominance h263 */
1043             uni_code= DCtab_chrom[size][0];
1044             uni_len = DCtab_chrom[size][1];
1045             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1046
1047             if (size > 0) {
1048                 uni_code<<=size; uni_code|=l;
1049                 uni_len+=size;
1050                 if (size > 8){
1051                     uni_code<<=1; uni_code|=1;
1052                     uni_len++;
1053                 }
1054             }
1055             v2_dc_chroma_table[level+256][0]= uni_code;
1056             v2_dc_chroma_table[level+256][1]= uni_len;
1057
1058         }
1059 }
1060
1061 /* init all vlc decoding tables */
1062 int ff_msmpeg4_decode_init(MpegEncContext *s)
1063 {
1064     static int done = 0;
1065     int i;
1066     MVTable *mv;
1067
1068     common_init(s);
1069
1070     if (!done) {
1071         done = 1;
1072
1073         for(i=0;i<NB_RL_TABLES;i++) {
1074             init_rl(&rl_table[i], static_rl_table_store[i]);
1075             init_vlc_rl(&rl_table[i], 1);
1076         }
1077         for(i=0;i<2;i++) {
1078             mv = &mv_tables[i];
1079             init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1080                      mv->table_mv_bits, 1, 1,
1081                      mv->table_mv_code, 2, 2, 1);
1082         }
1083
1084         init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1085                  &ff_table0_dc_lum[0][1], 8, 4,
1086                  &ff_table0_dc_lum[0][0], 8, 4, 1);
1087         init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1088                  &ff_table0_dc_chroma[0][1], 8, 4,
1089                  &ff_table0_dc_chroma[0][0], 8, 4, 1);
1090         init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1091                  &ff_table1_dc_lum[0][1], 8, 4,
1092                  &ff_table1_dc_lum[0][0], 8, 4, 1);
1093         init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1094                  &ff_table1_dc_chroma[0][1], 8, 4,
1095                  &ff_table1_dc_chroma[0][0], 8, 4, 1);
1096
1097         init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1098                  &v2_dc_lum_table[0][1], 8, 4,
1099                  &v2_dc_lum_table[0][0], 8, 4, 1);
1100         init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1101                  &v2_dc_chroma_table[0][1], 8, 4,
1102                  &v2_dc_chroma_table[0][0], 8, 4, 1);
1103
1104         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1105                  &cbpy_tab[0][1], 2, 1,
1106                  &cbpy_tab[0][0], 2, 1, 1);
1107         init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1108                  &v2_intra_cbpc[0][1], 2, 1,
1109                  &v2_intra_cbpc[0][0], 2, 1, 1);
1110         init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1111                  &v2_mb_type[0][1], 2, 1,
1112                  &v2_mb_type[0][0], 2, 1, 1);
1113         init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1114                  &mvtab[0][1], 2, 1,
1115                  &mvtab[0][0], 2, 1, 1);
1116
1117         for(i=0; i<4; i++){
1118             init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1119                      &wmv2_inter_table[i][0][1], 8, 4,
1120                      &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1121         }
1122
1123         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1124                  &ff_msmp4_mb_i_table[0][1], 4, 2,
1125                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1126
1127         init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1128                  intra_MCBPC_bits, 1, 1,
1129                  intra_MCBPC_code, 1, 1, 1);
1130         init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1131                  inter_MCBPC_bits, 1, 1,
1132                  inter_MCBPC_code, 1, 1, 1);
1133
1134         init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1135                  &table_inter_intra[0][1], 2, 1,
1136                  &table_inter_intra[0][0], 2, 1, 1);
1137     }
1138
1139     switch(s->msmpeg4_version){
1140     case 1:
1141     case 2:
1142         s->decode_mb= msmpeg4v12_decode_mb;
1143         break;
1144     case 3:
1145     case 4:
1146         s->decode_mb= msmpeg4v34_decode_mb;
1147         break;
1148     case 5:
1149         s->decode_mb= wmv2_decode_mb;
1150     case 6:
1151         //FIXME + TODO VC1 decode mb
1152         break;
1153     }
1154
1155     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1156
1157     return 0;
1158 }
1159
1160 int msmpeg4_decode_picture_header(MpegEncContext * s)
1161 {
1162     int code;
1163
1164 #if 0
1165 {
1166 int i;
1167 for(i=0; i<s->gb.size_in_bits; i++)
1168     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1169 //    get_bits1(&s->gb);
1170 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1171 return -1;
1172 }
1173 #endif
1174
1175     if(s->msmpeg4_version==1){
1176         int start_code, num;
1177         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1178         if(start_code!=0x00000100){
1179             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1180             return -1;
1181         }
1182
1183         num= get_bits(&s->gb, 5); // frame number */
1184     }
1185
1186     s->pict_type = get_bits(&s->gb, 2) + 1;
1187     if (s->pict_type != I_TYPE &&
1188         s->pict_type != P_TYPE){
1189         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1190         return -1;
1191     }
1192 #if 0
1193 {
1194     static int had_i=0;
1195     if(s->pict_type == I_TYPE) had_i=1;
1196     if(!had_i) return -1;
1197 }
1198 #endif
1199     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1200     if(s->qscale==0){
1201         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1202         return -1;
1203     }
1204
1205     if (s->pict_type == I_TYPE) {
1206         code = get_bits(&s->gb, 5);
1207         if(s->msmpeg4_version==1){
1208             if(code==0 || code>s->mb_height){
1209                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1210                 return -1;
1211             }
1212
1213             s->slice_height = code;
1214         }else{
1215             /* 0x17: one slice, 0x18: two slices, ... */
1216             if (code < 0x17){
1217                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1218                 return -1;
1219             }
1220
1221             s->slice_height = s->mb_height / (code - 0x16);
1222         }
1223
1224         switch(s->msmpeg4_version){
1225         case 1:
1226         case 2:
1227             s->rl_chroma_table_index = 2;
1228             s->rl_table_index = 2;
1229
1230             s->dc_table_index = 0; //not used
1231             break;
1232         case 3:
1233             s->rl_chroma_table_index = decode012(&s->gb);
1234             s->rl_table_index = decode012(&s->gb);
1235
1236             s->dc_table_index = get_bits1(&s->gb);
1237             break;
1238         case 4:
1239             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1240
1241             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1242             else                           s->per_mb_rl_table= 0;
1243
1244             if(!s->per_mb_rl_table){
1245                 s->rl_chroma_table_index = decode012(&s->gb);
1246                 s->rl_table_index = decode012(&s->gb);
1247             }
1248
1249             s->dc_table_index = get_bits1(&s->gb);
1250             s->inter_intra_pred= 0;
1251             break;
1252         }
1253         s->no_rounding = 1;
1254         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1255             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1256                 s->qscale,
1257                 s->rl_chroma_table_index,
1258                 s->rl_table_index,
1259                 s->dc_table_index,
1260                 s->per_mb_rl_table,
1261                 s->slice_height);
1262     } else {
1263         switch(s->msmpeg4_version){
1264         case 1:
1265         case 2:
1266             if(s->msmpeg4_version==1)
1267                 s->use_skip_mb_code = 1;
1268             else
1269                 s->use_skip_mb_code = get_bits1(&s->gb);
1270             s->rl_table_index = 2;
1271             s->rl_chroma_table_index = s->rl_table_index;
1272             s->dc_table_index = 0; //not used
1273             s->mv_table_index = 0;
1274             break;
1275         case 3:
1276             s->use_skip_mb_code = get_bits1(&s->gb);
1277             s->rl_table_index = decode012(&s->gb);
1278             s->rl_chroma_table_index = s->rl_table_index;
1279
1280             s->dc_table_index = get_bits1(&s->gb);
1281
1282             s->mv_table_index = get_bits1(&s->gb);
1283             break;
1284         case 4:
1285             s->use_skip_mb_code = get_bits1(&s->gb);
1286
1287             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1288             else                           s->per_mb_rl_table= 0;
1289
1290             if(!s->per_mb_rl_table){
1291                 s->rl_table_index = decode012(&s->gb);
1292                 s->rl_chroma_table_index = s->rl_table_index;
1293             }
1294
1295             s->dc_table_index = get_bits1(&s->gb);
1296
1297             s->mv_table_index = get_bits1(&s->gb);
1298             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1299             break;
1300         }
1301
1302         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1303             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1304                 s->use_skip_mb_code,
1305                 s->rl_table_index,
1306                 s->rl_chroma_table_index,
1307                 s->dc_table_index,
1308                 s->mv_table_index,
1309                 s->per_mb_rl_table,
1310                 s->qscale);
1311
1312         if(s->flipflop_rounding){
1313             s->no_rounding ^= 1;
1314         }else{
1315             s->no_rounding = 0;
1316         }
1317     }
1318 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1319
1320     s->esc3_level_length= 0;
1321     s->esc3_run_length= 0;
1322
1323 #ifdef DEBUG
1324     av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1325 #endif
1326     return 0;
1327 }
1328
1329 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1330 {
1331     int left= buf_size*8 - get_bits_count(&s->gb);
1332     int length= s->msmpeg4_version>=3 ? 17 : 16;
1333     /* the alt_bitstream reader could read over the end so we need to check it */
1334     if(left>=length && left<length+8)
1335     {
1336         int fps;
1337
1338         fps= get_bits(&s->gb, 5);
1339         s->bit_rate= get_bits(&s->gb, 11)*1024;
1340         if(s->msmpeg4_version>=3)
1341             s->flipflop_rounding= get_bits1(&s->gb);
1342         else
1343             s->flipflop_rounding= 0;
1344
1345 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1346     }
1347     else if(left<length+8)
1348     {
1349         s->flipflop_rounding= 0;
1350         if(s->msmpeg4_version != 2)
1351             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1352     }
1353     else
1354     {
1355         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1356     }
1357
1358     return 0;
1359 }
1360
1361 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1362 {
1363     int i;
1364     for(i=0;i<n;i++)
1365         tab[i] = val;
1366 }
1367
1368 #ifdef CONFIG_ENCODERS
1369 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1370 {
1371     int range, bit_size, sign, code, bits;
1372
1373     if (val == 0) {
1374         /* zero vector */
1375         code = 0;
1376         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1377     } else {
1378         bit_size = s->f_code - 1;
1379         range = 1 << bit_size;
1380         if (val <= -64)
1381             val += 64;
1382         else if (val >= 64)
1383             val -= 64;
1384
1385         if (val >= 0) {
1386             sign = 0;
1387         } else {
1388             val = -val;
1389             sign = 1;
1390         }
1391         val--;
1392         code = (val >> bit_size) + 1;
1393         bits = val & (range - 1);
1394
1395         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1396         if (bit_size > 0) {
1397             put_bits(&s->pb, bit_size, bits);
1398         }
1399     }
1400 }
1401 #endif
1402
1403 /* This is identical to h263 except that its range is multiplied by 2. */
1404 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1405 {
1406     int code, val, sign, shift;
1407
1408     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1409 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1410     if (code < 0)
1411         return 0xffff;
1412
1413     if (code == 0)
1414         return pred;
1415     sign = get_bits1(&s->gb);
1416     shift = f_code - 1;
1417     val = code;
1418     if (shift) {
1419         val = (val - 1) << shift;
1420         val |= get_bits(&s->gb, shift);
1421         val++;
1422     }
1423     if (sign)
1424         val = -val;
1425
1426     val += pred;
1427     if (val <= -64)
1428         val += 64;
1429     else if (val >= 64)
1430         val -= 64;
1431
1432     return val;
1433 }
1434
1435 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1436 {
1437     int cbp, code, i;
1438
1439     if (s->pict_type == P_TYPE) {
1440         if (s->use_skip_mb_code) {
1441             if (get_bits1(&s->gb)) {
1442                 /* skip mb */
1443                 s->mb_intra = 0;
1444                 for(i=0;i<6;i++)
1445                     s->block_last_index[i] = -1;
1446                 s->mv_dir = MV_DIR_FORWARD;
1447                 s->mv_type = MV_TYPE_16X16;
1448                 s->mv[0][0][0] = 0;
1449                 s->mv[0][0][1] = 0;
1450                 s->mb_skipped = 1;
1451                 return 0;
1452             }
1453         }
1454
1455         if(s->msmpeg4_version==2)
1456             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1457         else
1458             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1459         if(code<0 || code>7){
1460             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1461             return -1;
1462         }
1463
1464         s->mb_intra = code >>2;
1465
1466         cbp = code & 0x3;
1467     } else {
1468         s->mb_intra = 1;
1469         if(s->msmpeg4_version==2)
1470             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1471         else
1472             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1473         if(cbp<0 || cbp>3){
1474             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1475             return -1;
1476         }
1477     }
1478
1479     if (!s->mb_intra) {
1480         int mx, my, cbpy;
1481
1482         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1483         if(cbpy<0){
1484             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1485             return -1;
1486         }
1487
1488         cbp|= cbpy<<2;
1489         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1490
1491         h263_pred_motion(s, 0, 0, &mx, &my);
1492         mx= msmpeg4v2_decode_motion(s, mx, 1);
1493         my= msmpeg4v2_decode_motion(s, my, 1);
1494
1495         s->mv_dir = MV_DIR_FORWARD;
1496         s->mv_type = MV_TYPE_16X16;
1497         s->mv[0][0][0] = mx;
1498         s->mv[0][0][1] = my;
1499     } else {
1500         if(s->msmpeg4_version==2){
1501             s->ac_pred = get_bits1(&s->gb);
1502             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1503         } else{
1504             s->ac_pred = 0;
1505             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1506             if(s->pict_type==P_TYPE) cbp^=0x3C;
1507         }
1508     }
1509
1510     s->dsp.clear_blocks(s->block[0]);
1511     for (i = 0; i < 6; i++) {
1512         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1513         {
1514              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1515              return -1;
1516         }
1517     }
1518     return 0;
1519 }
1520
1521 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1522 {
1523     int cbp, code, i;
1524     uint8_t *coded_val;
1525     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1526
1527     if (s->pict_type == P_TYPE) {
1528         if (s->use_skip_mb_code) {
1529             if (get_bits1(&s->gb)) {
1530                 /* skip mb */
1531                 s->mb_intra = 0;
1532                 for(i=0;i<6;i++)
1533                     s->block_last_index[i] = -1;
1534                 s->mv_dir = MV_DIR_FORWARD;
1535                 s->mv_type = MV_TYPE_16X16;
1536                 s->mv[0][0][0] = 0;
1537                 s->mv[0][0][1] = 0;
1538                 s->mb_skipped = 1;
1539                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1540
1541                 return 0;
1542             }
1543         }
1544
1545         code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1546         if (code < 0)
1547             return -1;
1548         //s->mb_intra = (code & 0x40) ? 0 : 1;
1549         s->mb_intra = (~code & 0x40) >> 6;
1550
1551         cbp = code & 0x3f;
1552     } else {
1553         s->mb_intra = 1;
1554         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1555         if (code < 0)
1556             return -1;
1557         /* predict coded block pattern */
1558         cbp = 0;
1559         for(i=0;i<6;i++) {
1560             int val = ((code >> (5 - i)) & 1);
1561             if (i < 4) {
1562                 int pred = coded_block_pred(s, i, &coded_val);
1563                 val = val ^ pred;
1564                 *coded_val = val;
1565             }
1566             cbp |= val << (5 - i);
1567         }
1568     }
1569
1570     if (!s->mb_intra) {
1571         int mx, my;
1572 //printf("P at %d %d\n", s->mb_x, s->mb_y);
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         h263_pred_motion(s, 0, 0, &mx, &my);
1578         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1579             return -1;
1580         s->mv_dir = MV_DIR_FORWARD;
1581         s->mv_type = MV_TYPE_16X16;
1582         s->mv[0][0][0] = mx;
1583         s->mv[0][0][1] = my;
1584         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1585     } else {
1586 //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));
1587         s->ac_pred = get_bits1(&s->gb);
1588         *mb_type_ptr = MB_TYPE_INTRA;
1589         if(s->inter_intra_pred){
1590             s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1591 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1592         }
1593         if(s->per_mb_rl_table && cbp){
1594             s->rl_table_index = decode012(&s->gb);
1595             s->rl_chroma_table_index = s->rl_table_index;
1596         }
1597     }
1598
1599     s->dsp.clear_blocks(s->block[0]);
1600     for (i = 0; i < 6; i++) {
1601         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1602         {
1603             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1604             return -1;
1605         }
1606     }
1607
1608     return 0;
1609 }
1610 //#define ERROR_DETAILS
1611 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1612                               int n, int coded, const uint8_t *scan_table)
1613 {
1614     int level, i, last, run, run_diff;
1615     int dc_pred_dir;
1616     RLTable *rl;
1617     RL_VLC_ELEM *rl_vlc;
1618     int qmul, qadd;
1619
1620     if (s->mb_intra) {
1621         qmul=1;
1622         qadd=0;
1623
1624         /* DC coef */
1625         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1626
1627         if (level < 0){
1628             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1629             if(s->inter_intra_pred) level=0;
1630             else                    return -1;
1631         }
1632         if (n < 4) {
1633             rl = &rl_table[s->rl_table_index];
1634             if(level > 256*s->y_dc_scale){
1635                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1636                 if(!s->inter_intra_pred) return -1;
1637             }
1638         } else {
1639             rl = &rl_table[3 + s->rl_chroma_table_index];
1640             if(level > 256*s->c_dc_scale){
1641                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1642                 if(!s->inter_intra_pred) return -1;
1643             }
1644         }
1645         block[0] = level;
1646
1647         run_diff = s->msmpeg4_version >= 4;
1648         i = 0;
1649         if (!coded) {
1650             goto not_coded;
1651         }
1652         if (s->ac_pred) {
1653             if (dc_pred_dir == 0)
1654                 scan_table = s->intra_v_scantable.permutated; /* left */
1655             else
1656                 scan_table = s->intra_h_scantable.permutated; /* top */
1657         } else {
1658             scan_table = s->intra_scantable.permutated;
1659         }
1660         rl_vlc= rl->rl_vlc[0];
1661     } else {
1662         qmul = s->qscale << 1;
1663         qadd = (s->qscale - 1) | 1;
1664         i = -1;
1665         rl = &rl_table[3 + s->rl_table_index];
1666
1667         if(s->msmpeg4_version==2)
1668             run_diff = 0;
1669         else
1670             run_diff = 1;
1671
1672         if (!coded) {
1673             s->block_last_index[n] = i;
1674             return 0;
1675         }
1676         if(!scan_table)
1677             scan_table = s->inter_scantable.permutated;
1678         rl_vlc= rl->rl_vlc[s->qscale];
1679     }
1680   {
1681     OPEN_READER(re, &s->gb);
1682     for(;;) {
1683         UPDATE_CACHE(re, &s->gb);
1684         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1685         if (level==0) {
1686             int cache;
1687             cache= GET_CACHE(re, &s->gb);
1688             /* escape */
1689             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1690                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1691                     /* third escape */
1692                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1693                     UPDATE_CACHE(re, &s->gb);
1694                     if(s->msmpeg4_version<=3){
1695                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1696                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1697                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1698                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1699                     }else{
1700                         int sign;
1701                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1702                         if(!s->esc3_level_length){
1703                             int ll;
1704                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1705                             if(s->qscale<8){
1706                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1707                                 if(ll==0){
1708                                     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");
1709                                     SKIP_BITS(re, &s->gb, 1);
1710                                     ll=8;
1711                                 }
1712                             }else{
1713                                 ll=2;
1714                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1715                                     ll++;
1716                                     SKIP_BITS(re, &s->gb, 1);
1717                                 }
1718                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1719                             }
1720
1721                             s->esc3_level_length= ll;
1722                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1723 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1724                             UPDATE_CACHE(re, &s->gb);
1725                         }
1726                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1727                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1728
1729                         sign=  SHOW_UBITS(re, &s->gb, 1);
1730                         SKIP_BITS(re, &s->gb, 1);
1731
1732                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1733                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1734                         if(sign) level= -level;
1735                     }
1736 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1737 #if 0 // waste of time / this will detect very few errors
1738                     {
1739                         const int abs_level= FFABS(level);
1740                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1741                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1742                             if(abs_level <= rl->max_level[last][run]){
1743                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1744                                 return DECODING_AC_LOST;
1745                             }
1746                             if(abs_level <= rl->max_level[last][run]*2){
1747                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1748                                 return DECODING_AC_LOST;
1749                             }
1750                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1751                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1752                                 return DECODING_AC_LOST;
1753                             }
1754                         }
1755                     }
1756 #endif
1757                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1758                     if (level>0) level= level * qmul + qadd;
1759                     else         level= level * qmul - qadd;
1760 #if 0 // waste of time too :(
1761                     if(level>2048 || level<-2048){
1762                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1763                         return DECODING_AC_LOST;
1764                     }
1765 #endif
1766                     i+= run + 1;
1767                     if(last) i+=192;
1768 #ifdef ERROR_DETAILS
1769                 if(run==66)
1770                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1771                 else if((i>62 && i<192) || i>192+63)
1772                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1773 #endif
1774                 } else {
1775                     /* second escape */
1776 #if MIN_CACHE_BITS < 23
1777                     LAST_SKIP_BITS(re, &s->gb, 2);
1778                     UPDATE_CACHE(re, &s->gb);
1779 #else
1780                     SKIP_BITS(re, &s->gb, 2);
1781 #endif
1782                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1783                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //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 ESC2 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 ESC2 i=%d run=%d level=%d\n", i, run, level);
1791 #endif
1792                 }
1793             } else {
1794                 /* first escape */
1795 #if MIN_CACHE_BITS < 22
1796                 LAST_SKIP_BITS(re, &s->gb, 1);
1797                 UPDATE_CACHE(re, &s->gb);
1798 #else
1799                 SKIP_BITS(re, &s->gb, 1);
1800 #endif
1801                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1802                 i+= run;
1803                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1804                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1805                 LAST_SKIP_BITS(re, &s->gb, 1);
1806 #ifdef ERROR_DETAILS
1807                 if(run==66)
1808                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1809                 else if((i>62 && i<192) || i>192+63)
1810                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1811 #endif
1812             }
1813         } else {
1814             i+= run;
1815             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1816             LAST_SKIP_BITS(re, &s->gb, 1);
1817 #ifdef ERROR_DETAILS
1818                 if(run==66)
1819                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1820                 else if((i>62 && i<192) || i>192+63)
1821                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1822 #endif
1823         }
1824         if (i > 62){
1825             i-= 192;
1826             if(i&(~63)){
1827                 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1828                 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1829                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1830                     break;
1831                 }else{
1832                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1833                     return -1;
1834                 }
1835             }
1836
1837             block[scan_table[i]] = level;
1838             break;
1839         }
1840
1841         block[scan_table[i]] = level;
1842     }
1843     CLOSE_READER(re, &s->gb);
1844   }
1845  not_coded:
1846     if (s->mb_intra) {
1847         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1848         if (s->ac_pred) {
1849             i = 63; /* XXX: not optimal */
1850         }
1851     }
1852     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1853     s->block_last_index[n] = i;
1854
1855     return 0;
1856 }
1857
1858 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1859 {
1860     int level, pred;
1861
1862     if(s->msmpeg4_version<=2){
1863         if (n < 4) {
1864             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1865         } else {
1866             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1867         }
1868         if (level < 0)
1869             return -1;
1870         level-=256;
1871     }else{  //FIXME optimize use unified tables & index
1872         if (n < 4) {
1873             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1874         } else {
1875             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1876         }
1877         if (level < 0){
1878             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1879             return -1;
1880         }
1881
1882         if (level == DC_MAX) {
1883             level = get_bits(&s->gb, 8);
1884             if (get_bits1(&s->gb))
1885                 level = -level;
1886         } else if (level != 0) {
1887             if (get_bits1(&s->gb))
1888                 level = -level;
1889         }
1890     }
1891
1892     if(s->msmpeg4_version==1){
1893         int32_t *dc_val;
1894         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1895         level += pred;
1896
1897         /* update predictor */
1898         *dc_val= level;
1899     }else{
1900         int16_t *dc_val;
1901         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1902         level += pred;
1903
1904         /* update predictor */
1905         if (n < 4) {
1906             *dc_val = level * s->y_dc_scale;
1907         } else {
1908             *dc_val = level * s->c_dc_scale;
1909         }
1910     }
1911
1912     return level;
1913 }
1914
1915 static int msmpeg4_decode_motion(MpegEncContext * s,
1916                                  int *mx_ptr, int *my_ptr)
1917 {
1918     MVTable *mv;
1919     int code, mx, my;
1920
1921     mv = &mv_tables[s->mv_table_index];
1922
1923     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1924     if (code < 0){
1925         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1926         return -1;
1927     }
1928     if (code == mv->n) {
1929 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1930         mx = get_bits(&s->gb, 6);
1931         my = get_bits(&s->gb, 6);
1932     } else {
1933         mx = mv->table_mvx[code];
1934         my = mv->table_mvy[code];
1935     }
1936
1937     mx += *mx_ptr - 32;
1938     my += *my_ptr - 32;
1939     /* WARNING : they do not do exactly modulo encoding */
1940     if (mx <= -64)
1941         mx += 64;
1942     else if (mx >= 64)
1943         mx -= 64;
1944
1945     if (my <= -64)
1946         my += 64;
1947     else if (my >= 64)
1948         my -= 64;
1949     *mx_ptr = mx;
1950     *my_ptr = my;
1951     return 0;
1952 }
1953
1954 /* cleanest way to support it
1955  * there is too much shared between versions so that we cant have 1 file per version & 1 common
1956  * as allmost everything would be in the common file
1957  */
1958 #include "wmv2.c"