Rename y400a to gray8a.
[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
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
989             s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
990
991             code = get_rl_index(rl, last, run, level);
992             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
993             if (code == rl->n) {
994                 int level1, run1;
995
996                 level1 = level - rl->max_level[last][run];
997                 if (level1 < 1)
998                     goto esc2;
999                 code = get_rl_index(rl, last, run, level1);
1000                 if (code == rl->n) {
1001                 esc2:
1002                     put_bits(&s->pb, 1, 0);
1003                     if (level > MAX_LEVEL)
1004                         goto esc3;
1005                     run1 = run - rl->max_run[last][level] - run_diff;
1006                     if (run1 < 0)
1007                         goto esc3;
1008                     code = get_rl_index(rl, last, run1+1, level);
1009                     if (s->msmpeg4_version == 4 && code == rl->n)
1010                         goto esc3;
1011                     code = get_rl_index(rl, last, run1, level);
1012                     if (code == rl->n) {
1013                     esc3:
1014                         /* third escape */
1015                         put_bits(&s->pb, 1, 0);
1016                         put_bits(&s->pb, 1, last);
1017                         if(s->msmpeg4_version>=4){
1018                             if(s->esc3_level_length==0){
1019                                 s->esc3_level_length=8;
1020                                 s->esc3_run_length= 6;
1021                                 //ESCLVLSZ + ESCRUNSZ
1022                                 if(s->qscale<8)
1023                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1024                                 else
1025                                     put_bits(&s->pb, 8, 3);
1026                             }
1027                             put_bits(&s->pb, s->esc3_run_length, run);
1028                             put_bits(&s->pb, 1, sign);
1029                             put_bits(&s->pb, s->esc3_level_length, level);
1030                         }else{
1031                             put_bits(&s->pb, 6, run);
1032                             put_sbits(&s->pb, 8, slevel);
1033                         }
1034                     } else {
1035                         /* second escape */
1036                         put_bits(&s->pb, 1, 1);
1037                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1038                         put_bits(&s->pb, 1, sign);
1039                     }
1040                 } else {
1041                     /* first escape */
1042                     put_bits(&s->pb, 1, 1);
1043                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1044                     put_bits(&s->pb, 1, sign);
1045                 }
1046             } else {
1047                 put_bits(&s->pb, 1, sign);
1048             }
1049             last_non_zero = i;
1050         }
1051     }
1052 }
1053
1054 /****************************************/
1055 /* decoding stuff */
1056
1057 VLC ff_mb_non_intra_vlc[4];
1058 static VLC v2_dc_lum_vlc;
1059 static VLC v2_dc_chroma_vlc;
1060 static VLC v2_intra_cbpc_vlc;
1061 static VLC v2_mb_type_vlc;
1062 static VLC v2_mv_vlc;
1063 VLC ff_inter_intra_vlc;
1064
1065 /* This is identical to h263 except that its range is multiplied by 2. */
1066 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1067 {
1068     int code, val, sign, shift;
1069
1070     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1071 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1072     if (code < 0)
1073         return 0xffff;
1074
1075     if (code == 0)
1076         return pred;
1077     sign = get_bits1(&s->gb);
1078     shift = f_code - 1;
1079     val = code;
1080     if (shift) {
1081         val = (val - 1) << shift;
1082         val |= get_bits(&s->gb, shift);
1083         val++;
1084     }
1085     if (sign)
1086         val = -val;
1087
1088     val += pred;
1089     if (val <= -64)
1090         val += 64;
1091     else if (val >= 64)
1092         val -= 64;
1093
1094     return val;
1095 }
1096
1097 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1098 {
1099     int cbp, code, i;
1100
1101     if (s->pict_type == FF_P_TYPE) {
1102         if (s->use_skip_mb_code) {
1103             if (get_bits1(&s->gb)) {
1104                 /* skip mb */
1105                 s->mb_intra = 0;
1106                 for(i=0;i<6;i++)
1107                     s->block_last_index[i] = -1;
1108                 s->mv_dir = MV_DIR_FORWARD;
1109                 s->mv_type = MV_TYPE_16X16;
1110                 s->mv[0][0][0] = 0;
1111                 s->mv[0][0][1] = 0;
1112                 s->mb_skipped = 1;
1113                 return 0;
1114             }
1115         }
1116
1117         if(s->msmpeg4_version==2)
1118             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1119         else
1120             code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1121         if(code<0 || code>7){
1122             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1123             return -1;
1124         }
1125
1126         s->mb_intra = code >>2;
1127
1128         cbp = code & 0x3;
1129     } else {
1130         s->mb_intra = 1;
1131         if(s->msmpeg4_version==2)
1132             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1133         else
1134             cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1135         if(cbp<0 || cbp>3){
1136             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1137             return -1;
1138         }
1139     }
1140
1141     if (!s->mb_intra) {
1142         int mx, my, cbpy;
1143
1144         cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1145         if(cbpy<0){
1146             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1147             return -1;
1148         }
1149
1150         cbp|= cbpy<<2;
1151         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1152
1153         h263_pred_motion(s, 0, 0, &mx, &my);
1154         mx= msmpeg4v2_decode_motion(s, mx, 1);
1155         my= msmpeg4v2_decode_motion(s, my, 1);
1156
1157         s->mv_dir = MV_DIR_FORWARD;
1158         s->mv_type = MV_TYPE_16X16;
1159         s->mv[0][0][0] = mx;
1160         s->mv[0][0][1] = my;
1161     } else {
1162         if(s->msmpeg4_version==2){
1163             s->ac_pred = get_bits1(&s->gb);
1164             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1165         } else{
1166             s->ac_pred = 0;
1167             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1168             if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1169         }
1170     }
1171
1172     s->dsp.clear_blocks(s->block[0]);
1173     for (i = 0; i < 6; i++) {
1174         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1175         {
1176              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1177              return -1;
1178         }
1179     }
1180     return 0;
1181 }
1182
1183 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1184 {
1185     int cbp, code, i;
1186     uint8_t *coded_val;
1187     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1188
1189     if (s->pict_type == FF_P_TYPE) {
1190         if (s->use_skip_mb_code) {
1191             if (get_bits1(&s->gb)) {
1192                 /* skip mb */
1193                 s->mb_intra = 0;
1194                 for(i=0;i<6;i++)
1195                     s->block_last_index[i] = -1;
1196                 s->mv_dir = MV_DIR_FORWARD;
1197                 s->mv_type = MV_TYPE_16X16;
1198                 s->mv[0][0][0] = 0;
1199                 s->mv[0][0][1] = 0;
1200                 s->mb_skipped = 1;
1201                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1202
1203                 return 0;
1204             }
1205         }
1206
1207         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1208         if (code < 0)
1209             return -1;
1210         //s->mb_intra = (code & 0x40) ? 0 : 1;
1211         s->mb_intra = (~code & 0x40) >> 6;
1212
1213         cbp = code & 0x3f;
1214     } else {
1215         s->mb_intra = 1;
1216         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1217         if (code < 0)
1218             return -1;
1219         /* predict coded block pattern */
1220         cbp = 0;
1221         for(i=0;i<6;i++) {
1222             int val = ((code >> (5 - i)) & 1);
1223             if (i < 4) {
1224                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1225                 val = val ^ pred;
1226                 *coded_val = val;
1227             }
1228             cbp |= val << (5 - i);
1229         }
1230     }
1231
1232     if (!s->mb_intra) {
1233         int mx, my;
1234 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1235         if(s->per_mb_rl_table && cbp){
1236             s->rl_table_index = decode012(&s->gb);
1237             s->rl_chroma_table_index = s->rl_table_index;
1238         }
1239         h263_pred_motion(s, 0, 0, &mx, &my);
1240         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1241             return -1;
1242         s->mv_dir = MV_DIR_FORWARD;
1243         s->mv_type = MV_TYPE_16X16;
1244         s->mv[0][0][0] = mx;
1245         s->mv[0][0][1] = my;
1246         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1247     } else {
1248 //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));
1249         s->ac_pred = get_bits1(&s->gb);
1250         *mb_type_ptr = MB_TYPE_INTRA;
1251         if(s->inter_intra_pred){
1252             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1253 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1254         }
1255         if(s->per_mb_rl_table && cbp){
1256             s->rl_table_index = decode012(&s->gb);
1257             s->rl_chroma_table_index = s->rl_table_index;
1258         }
1259     }
1260
1261     s->dsp.clear_blocks(s->block[0]);
1262     for (i = 0; i < 6; i++) {
1263         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1264         {
1265             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1266             return -1;
1267         }
1268     }
1269
1270     return 0;
1271 }
1272
1273 /* init all vlc decoding tables */
1274 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1275 {
1276     MpegEncContext *s = avctx->priv_data;
1277     static int done = 0;
1278     int i;
1279     MVTable *mv;
1280
1281     if (ff_h263_decode_init(avctx) < 0)
1282         return -1;
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 = get_bits_long(&s->gb, 32);
1399         if(start_code!=0x00000100){
1400             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1401             return -1;
1402         }
1403
1404         skip_bits(&s->gb, 5); // frame number */
1405     }
1406
1407     s->pict_type = get_bits(&s->gb, 2) + 1;
1408     if (s->pict_type != FF_I_TYPE &&
1409         s->pict_type != FF_P_TYPE){
1410         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1411         return -1;
1412     }
1413 #if 0
1414 {
1415     static int had_i=0;
1416     if(s->pict_type == FF_I_TYPE) had_i=1;
1417     if(!had_i) return -1;
1418 }
1419 #endif
1420     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1421     if(s->qscale==0){
1422         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1423         return -1;
1424     }
1425
1426     if (s->pict_type == FF_I_TYPE) {
1427         code = get_bits(&s->gb, 5);
1428         if(s->msmpeg4_version==1){
1429             if(code==0 || code>s->mb_height){
1430                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1431                 return -1;
1432             }
1433
1434             s->slice_height = code;
1435         }else{
1436             /* 0x17: one slice, 0x18: two slices, ... */
1437             if (code < 0x17){
1438                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1439                 return -1;
1440             }
1441
1442             s->slice_height = s->mb_height / (code - 0x16);
1443         }
1444
1445         switch(s->msmpeg4_version){
1446         case 1:
1447         case 2:
1448             s->rl_chroma_table_index = 2;
1449             s->rl_table_index = 2;
1450
1451             s->dc_table_index = 0; //not used
1452             break;
1453         case 3:
1454             s->rl_chroma_table_index = decode012(&s->gb);
1455             s->rl_table_index = decode012(&s->gb);
1456
1457             s->dc_table_index = get_bits1(&s->gb);
1458             break;
1459         case 4:
1460             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1461
1462             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1463             else                           s->per_mb_rl_table= 0;
1464
1465             if(!s->per_mb_rl_table){
1466                 s->rl_chroma_table_index = decode012(&s->gb);
1467                 s->rl_table_index = decode012(&s->gb);
1468             }
1469
1470             s->dc_table_index = get_bits1(&s->gb);
1471             s->inter_intra_pred= 0;
1472             break;
1473         }
1474         s->no_rounding = 1;
1475         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1476             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1477                 s->qscale,
1478                 s->rl_chroma_table_index,
1479                 s->rl_table_index,
1480                 s->dc_table_index,
1481                 s->per_mb_rl_table,
1482                 s->slice_height);
1483     } else {
1484         switch(s->msmpeg4_version){
1485         case 1:
1486         case 2:
1487             if(s->msmpeg4_version==1)
1488                 s->use_skip_mb_code = 1;
1489             else
1490                 s->use_skip_mb_code = get_bits1(&s->gb);
1491             s->rl_table_index = 2;
1492             s->rl_chroma_table_index = s->rl_table_index;
1493             s->dc_table_index = 0; //not used
1494             s->mv_table_index = 0;
1495             break;
1496         case 3:
1497             s->use_skip_mb_code = get_bits1(&s->gb);
1498             s->rl_table_index = decode012(&s->gb);
1499             s->rl_chroma_table_index = s->rl_table_index;
1500
1501             s->dc_table_index = get_bits1(&s->gb);
1502
1503             s->mv_table_index = get_bits1(&s->gb);
1504             break;
1505         case 4:
1506             s->use_skip_mb_code = get_bits1(&s->gb);
1507
1508             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1509             else                           s->per_mb_rl_table= 0;
1510
1511             if(!s->per_mb_rl_table){
1512                 s->rl_table_index = decode012(&s->gb);
1513                 s->rl_chroma_table_index = s->rl_table_index;
1514             }
1515
1516             s->dc_table_index = get_bits1(&s->gb);
1517
1518             s->mv_table_index = get_bits1(&s->gb);
1519             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1520             break;
1521         }
1522
1523         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1524             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1525                 s->use_skip_mb_code,
1526                 s->rl_table_index,
1527                 s->rl_chroma_table_index,
1528                 s->dc_table_index,
1529                 s->mv_table_index,
1530                 s->per_mb_rl_table,
1531                 s->qscale);
1532
1533         if(s->flipflop_rounding){
1534             s->no_rounding ^= 1;
1535         }else{
1536             s->no_rounding = 0;
1537         }
1538     }
1539 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1540
1541     s->esc3_level_length= 0;
1542     s->esc3_run_length= 0;
1543
1544     return 0;
1545 }
1546
1547 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1548 {
1549     int left= buf_size*8 - get_bits_count(&s->gb);
1550     int length= s->msmpeg4_version>=3 ? 17 : 16;
1551     /* the alt_bitstream reader could read over the end so we need to check it */
1552     if(left>=length && left<length+8)
1553     {
1554         int fps;
1555
1556         fps= get_bits(&s->gb, 5);
1557         s->bit_rate= get_bits(&s->gb, 11)*1024;
1558         if(s->msmpeg4_version>=3)
1559             s->flipflop_rounding= get_bits1(&s->gb);
1560         else
1561             s->flipflop_rounding= 0;
1562
1563 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1564     }
1565     else if(left<length+8)
1566     {
1567         s->flipflop_rounding= 0;
1568         if(s->msmpeg4_version != 2)
1569             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1570     }
1571     else
1572     {
1573         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1574     }
1575
1576     return 0;
1577 }
1578
1579 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1580 {
1581     int level, pred;
1582
1583     if(s->msmpeg4_version<=2){
1584         if (n < 4) {
1585             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1586         } else {
1587             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1588         }
1589         if (level < 0)
1590             return -1;
1591         level-=256;
1592     }else{  //FIXME optimize use unified tables & index
1593         if (n < 4) {
1594             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1595         } else {
1596             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1597         }
1598         if (level < 0){
1599             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1600             return -1;
1601         }
1602
1603         if (level == DC_MAX) {
1604             level = get_bits(&s->gb, 8);
1605             if (get_bits1(&s->gb))
1606                 level = -level;
1607         } else if (level != 0) {
1608             if (get_bits1(&s->gb))
1609                 level = -level;
1610         }
1611     }
1612
1613     if(s->msmpeg4_version==1){
1614         int32_t *dc_val;
1615         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1616         level += pred;
1617
1618         /* update predictor */
1619         *dc_val= level;
1620     }else{
1621         int16_t *dc_val;
1622         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1623         level += pred;
1624
1625         /* update predictor */
1626         if (n < 4) {
1627             *dc_val = level * s->y_dc_scale;
1628         } else {
1629             *dc_val = level * s->c_dc_scale;
1630         }
1631     }
1632
1633     return level;
1634 }
1635
1636 //#define ERROR_DETAILS
1637 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1638                               int n, int coded, const uint8_t *scan_table)
1639 {
1640     int level, i, last, run, run_diff;
1641     int av_uninit(dc_pred_dir);
1642     RLTable *rl;
1643     RL_VLC_ELEM *rl_vlc;
1644     int qmul, qadd;
1645
1646     if (s->mb_intra) {
1647         qmul=1;
1648         qadd=0;
1649
1650         /* DC coef */
1651         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1652
1653         if (level < 0){
1654             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1655             if(s->inter_intra_pred) level=0;
1656             else                    return -1;
1657         }
1658         if (n < 4) {
1659             rl = &rl_table[s->rl_table_index];
1660             if(level > 256*s->y_dc_scale){
1661                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1662                 if(!s->inter_intra_pred) return -1;
1663             }
1664         } else {
1665             rl = &rl_table[3 + s->rl_chroma_table_index];
1666             if(level > 256*s->c_dc_scale){
1667                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1668                 if(!s->inter_intra_pred) return -1;
1669             }
1670         }
1671         block[0] = level;
1672
1673         run_diff = s->msmpeg4_version >= 4;
1674         i = 0;
1675         if (!coded) {
1676             goto not_coded;
1677         }
1678         if (s->ac_pred) {
1679             if (dc_pred_dir == 0)
1680                 scan_table = s->intra_v_scantable.permutated; /* left */
1681             else
1682                 scan_table = s->intra_h_scantable.permutated; /* top */
1683         } else {
1684             scan_table = s->intra_scantable.permutated;
1685         }
1686         rl_vlc= rl->rl_vlc[0];
1687     } else {
1688         qmul = s->qscale << 1;
1689         qadd = (s->qscale - 1) | 1;
1690         i = -1;
1691         rl = &rl_table[3 + s->rl_table_index];
1692
1693         if(s->msmpeg4_version==2)
1694             run_diff = 0;
1695         else
1696             run_diff = 1;
1697
1698         if (!coded) {
1699             s->block_last_index[n] = i;
1700             return 0;
1701         }
1702         if(!scan_table)
1703             scan_table = s->inter_scantable.permutated;
1704         rl_vlc= rl->rl_vlc[s->qscale];
1705     }
1706   {
1707     OPEN_READER(re, &s->gb);
1708     for(;;) {
1709         UPDATE_CACHE(re, &s->gb);
1710         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1711         if (level==0) {
1712             int cache;
1713             cache= GET_CACHE(re, &s->gb);
1714             /* escape */
1715             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1716                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1717                     /* third escape */
1718                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1719                     UPDATE_CACHE(re, &s->gb);
1720                     if(s->msmpeg4_version<=3){
1721                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1722                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1723                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1724                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1725                     }else{
1726                         int sign;
1727                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1728                         if(!s->esc3_level_length){
1729                             int ll;
1730                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1731                             if(s->qscale<8){
1732                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1733                                 if(ll==0){
1734                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1735                                 }
1736                             }else{
1737                                 ll=2;
1738                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1739                                     ll++;
1740                                     SKIP_BITS(re, &s->gb, 1);
1741                                 }
1742                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1743                             }
1744
1745                             s->esc3_level_length= ll;
1746                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1747 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1748                             UPDATE_CACHE(re, &s->gb);
1749                         }
1750                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1751                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1752
1753                         sign=  SHOW_UBITS(re, &s->gb, 1);
1754                         SKIP_BITS(re, &s->gb, 1);
1755
1756                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1757                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1758                         if(sign) level= -level;
1759                     }
1760 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1761 #if 0 // waste of time / this will detect very few errors
1762                     {
1763                         const int abs_level= FFABS(level);
1764                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1765                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1766                             if(abs_level <= rl->max_level[last][run]){
1767                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1768                                 return DECODING_AC_LOST;
1769                             }
1770                             if(abs_level <= rl->max_level[last][run]*2){
1771                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1772                                 return DECODING_AC_LOST;
1773                             }
1774                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1775                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1776                                 return DECODING_AC_LOST;
1777                             }
1778                         }
1779                     }
1780 #endif
1781                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1782                     if (level>0) level= level * qmul + qadd;
1783                     else         level= level * qmul - qadd;
1784 #if 0 // waste of time too :(
1785                     if(level>2048 || level<-2048){
1786                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1787                         return DECODING_AC_LOST;
1788                     }
1789 #endif
1790                     i+= run + 1;
1791                     if(last) i+=192;
1792 #ifdef ERROR_DETAILS
1793                 if(run==66)
1794                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1795                 else if((i>62 && i<192) || i>192+63)
1796                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1797 #endif
1798                 } else {
1799                     /* second escape */
1800                     SKIP_BITS(re, &s->gb, 2);
1801                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1802                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1803                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1804                     LAST_SKIP_BITS(re, &s->gb, 1);
1805 #ifdef ERROR_DETAILS
1806                 if(run==66)
1807                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1808                 else if((i>62 && i<192) || i>192+63)
1809                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1810 #endif
1811                 }
1812             } else {
1813                 /* first escape */
1814                 SKIP_BITS(re, &s->gb, 1);
1815                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1816                 i+= run;
1817                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1818                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1819                 LAST_SKIP_BITS(re, &s->gb, 1);
1820 #ifdef ERROR_DETAILS
1821                 if(run==66)
1822                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1823                 else if((i>62 && i<192) || i>192+63)
1824                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1825 #endif
1826             }
1827         } else {
1828             i+= run;
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 level=%d\n", level);
1834                 else if((i>62 && i<192) || i>192+63)
1835                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1836 #endif
1837         }
1838         if (i > 62){
1839             i-= 192;
1840             if(i&(~63)){
1841                 const int left= get_bits_left(&s->gb);
1842                 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1843                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1844                     break;
1845                 }else{
1846                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1847                     return -1;
1848                 }
1849             }
1850
1851             block[scan_table[i]] = level;
1852             break;
1853         }
1854
1855         block[scan_table[i]] = level;
1856     }
1857     CLOSE_READER(re, &s->gb);
1858   }
1859  not_coded:
1860     if (s->mb_intra) {
1861         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1862         if (s->ac_pred) {
1863             i = 63; /* XXX: not optimal */
1864         }
1865     }
1866     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1867     s->block_last_index[n] = i;
1868
1869     return 0;
1870 }
1871
1872 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1873                                  int *mx_ptr, int *my_ptr)
1874 {
1875     MVTable *mv;
1876     int code, mx, my;
1877
1878     mv = &mv_tables[s->mv_table_index];
1879
1880     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1881     if (code < 0){
1882         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1883         return -1;
1884     }
1885     if (code == mv->n) {
1886 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1887         mx = get_bits(&s->gb, 6);
1888         my = get_bits(&s->gb, 6);
1889     } else {
1890         mx = mv->table_mvx[code];
1891         my = mv->table_mvy[code];
1892     }
1893
1894     mx += *mx_ptr - 32;
1895     my += *my_ptr - 32;
1896     /* WARNING : they do not do exactly modulo encoding */
1897     if (mx <= -64)
1898         mx += 64;
1899     else if (mx >= 64)
1900         mx -= 64;
1901
1902     if (my <= -64)
1903         my += 64;
1904     else if (my >= 64)
1905         my -= 64;
1906     *mx_ptr = mx;
1907     *my_ptr = my;
1908     return 0;
1909 }
1910
1911 AVCodec ff_msmpeg4v1_decoder = {
1912     "msmpeg4v1",
1913     AVMEDIA_TYPE_VIDEO,
1914     CODEC_ID_MSMPEG4V1,
1915     sizeof(MpegEncContext),
1916     ff_msmpeg4_decode_init,
1917     NULL,
1918     ff_h263_decode_end,
1919     ff_h263_decode_frame,
1920     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
1921     .max_lowres= 3,
1922     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1923     .pix_fmts= ff_pixfmt_list_420,
1924 };
1925
1926 AVCodec ff_msmpeg4v2_decoder = {
1927     "msmpeg4v2",
1928     AVMEDIA_TYPE_VIDEO,
1929     CODEC_ID_MSMPEG4V2,
1930     sizeof(MpegEncContext),
1931     ff_msmpeg4_decode_init,
1932     NULL,
1933     ff_h263_decode_end,
1934     ff_h263_decode_frame,
1935     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1936     .max_lowres= 3,
1937     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1938     .pix_fmts= ff_pixfmt_list_420,
1939 };
1940
1941 AVCodec ff_msmpeg4v3_decoder = {
1942     "msmpeg4",
1943     AVMEDIA_TYPE_VIDEO,
1944     CODEC_ID_MSMPEG4V3,
1945     sizeof(MpegEncContext),
1946     ff_msmpeg4_decode_init,
1947     NULL,
1948     ff_h263_decode_end,
1949     ff_h263_decode_frame,
1950     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1951     .max_lowres= 3,
1952     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1953     .pix_fmts= ff_pixfmt_list_420,
1954 };
1955
1956 AVCodec ff_wmv1_decoder = {
1957     "wmv1",
1958     AVMEDIA_TYPE_VIDEO,
1959     CODEC_ID_WMV1,
1960     sizeof(MpegEncContext),
1961     ff_msmpeg4_decode_init,
1962     NULL,
1963     ff_h263_decode_end,
1964     ff_h263_decode_frame,
1965     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1966     .max_lowres= 3,
1967     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1968     .pix_fmts= ff_pixfmt_list_420,
1969 };