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