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