VP8: idct_mb optimizations
[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 #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 = 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,
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 };