1ba3cdb2faf32c27f9c2a3e1ffed5633e867a710
[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
621         if(s->msmpeg4_version<=2){
622             if (s->pict_type == FF_I_TYPE) {
623                 put_bits(&s->pb,
624                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
625             } else {
626                 if (s->use_skip_mb_code)
627                     put_bits(&s->pb, 1, 0);     /* mb coded */
628                 put_bits(&s->pb,
629                          v2_mb_type[(cbp&3) + 4][1],
630                          v2_mb_type[(cbp&3) + 4][0]);
631             }
632             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
633             put_bits(&s->pb,
634                      ff_h263_cbpy_tab[cbp>>2][1],
635                      ff_h263_cbpy_tab[cbp>>2][0]);
636         }else{
637             if (s->pict_type == FF_I_TYPE) {
638                 put_bits(&s->pb,
639                          ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
640             } else {
641                 if (s->use_skip_mb_code)
642                     put_bits(&s->pb, 1, 0);     /* mb coded */
643                 put_bits(&s->pb,
644                          table_mb_non_intra[cbp][1],
645                          table_mb_non_intra[cbp][0]);
646             }
647             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
648             if(s->inter_intra_pred){
649                 s->h263_aic_dir=0;
650                 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
651             }
652         }
653         s->misc_bits += get_bits_diff(s);
654
655         for (i = 0; i < 6; i++) {
656             ff_msmpeg4_encode_block(s, block[i], i);
657         }
658         s->i_tex_bits += get_bits_diff(s);
659         s->i_count++;
660     }
661 }
662
663 #endif //CONFIG_ENCODERS
664
665 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
666                                     int32_t **dc_val_ptr)
667 {
668     int i;
669
670     if (n < 4) {
671         i= 0;
672     } else {
673         i= n-3;
674     }
675
676     *dc_val_ptr= &s->last_dc[i];
677     return s->last_dc[i];
678 }
679
680 static int get_dc(uint8_t *src, int stride, int scale)
681 {
682     int y;
683     int sum=0;
684     for(y=0; y<8; y++){
685         int x;
686         for(x=0; x<8; x++){
687             sum+=src[x + y*stride];
688         }
689     }
690     return FASTDIV((sum + (scale>>1)), scale);
691 }
692
693 /* dir = 0: left, dir = 1: top prediction */
694 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
695                              int16_t **dc_val_ptr, int *dir_ptr)
696 {
697     int a, b, c, wrap, pred, scale;
698     int16_t *dc_val;
699
700     /* find prediction */
701     if (n < 4) {
702         scale = s->y_dc_scale;
703     } else {
704         scale = s->c_dc_scale;
705     }
706
707     wrap = s->block_wrap[n];
708     dc_val= s->dc_val[0] + s->block_index[n];
709
710     /* B C
711      * A X
712      */
713     a = dc_val[ - 1];
714     b = dc_val[ - 1 - wrap];
715     c = dc_val[ - wrap];
716
717     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
718         b=c=1024;
719     }
720
721     /* XXX: the following solution consumes divisions, but it does not
722        necessitate to modify mpegvideo.c. The problem comes from the
723        fact they decided to store the quantized DC (which would lead
724        to problems if Q could vary !) */
725 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
726     __asm__ volatile(
727         "movl %3, %%eax         \n\t"
728         "shrl $1, %%eax         \n\t"
729         "addl %%eax, %2         \n\t"
730         "addl %%eax, %1         \n\t"
731         "addl %0, %%eax         \n\t"
732         "mull %4                \n\t"
733         "movl %%edx, %0         \n\t"
734         "movl %1, %%eax         \n\t"
735         "mull %4                \n\t"
736         "movl %%edx, %1         \n\t"
737         "movl %2, %%eax         \n\t"
738         "mull %4                \n\t"
739         "movl %%edx, %2         \n\t"
740         : "+b" (a), "+c" (b), "+D" (c)
741         : "g" (scale), "S" (ff_inverse[scale])
742         : "%eax", "%edx"
743     );
744 #else
745     /* #elif ARCH_ALPHA */
746     /* Divisions are extremely costly on Alpha; optimize the most
747        common case. But they are costly everywhere...
748      */
749     if (scale == 8) {
750         a = (a + (8 >> 1)) / 8;
751         b = (b + (8 >> 1)) / 8;
752         c = (c + (8 >> 1)) / 8;
753     } else {
754         a = FASTDIV((a + (scale >> 1)), scale);
755         b = FASTDIV((b + (scale >> 1)), scale);
756         c = FASTDIV((c + (scale >> 1)), scale);
757     }
758 #endif
759     /* XXX: WARNING: they did not choose the same test as MPEG4. This
760        is very important ! */
761     if(s->msmpeg4_version>3){
762         if(s->inter_intra_pred){
763             uint8_t *dest;
764             int wrap;
765
766             if(n==1){
767                 pred=a;
768                 *dir_ptr = 0;
769             }else if(n==2){
770                 pred=c;
771                 *dir_ptr = 1;
772             }else if(n==3){
773                 if (abs(a - b) < abs(b - c)) {
774                     pred = c;
775                     *dir_ptr = 1;
776                 } else {
777                     pred = a;
778                     *dir_ptr = 0;
779                 }
780             }else{
781                 if(n<4){
782                     wrap= s->linesize;
783                     dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
784                 }else{
785                     wrap= s->uvlinesize;
786                     dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
787                 }
788                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
789                 else           a= get_dc(dest-8, wrap, scale*8);
790                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
791                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
792
793                 if (s->h263_aic_dir==0) {
794                     pred= a;
795                     *dir_ptr = 0;
796                 }else if (s->h263_aic_dir==1) {
797                     if(n==0){
798                         pred= c;
799                         *dir_ptr = 1;
800                     }else{
801                         pred= a;
802                         *dir_ptr = 0;
803                     }
804                 }else if (s->h263_aic_dir==2) {
805                     if(n==0){
806                         pred= a;
807                         *dir_ptr = 0;
808                     }else{
809                         pred= c;
810                         *dir_ptr = 1;
811                     }
812                 } else {
813                     pred= c;
814                     *dir_ptr = 1;
815                 }
816             }
817         }else{
818             if (abs(a - b) < abs(b - c)) {
819                 pred = c;
820                 *dir_ptr = 1;
821             } else {
822                 pred = a;
823                 *dir_ptr = 0;
824             }
825         }
826     }else{
827         if (abs(a - b) <= abs(b - c)) {
828             pred = c;
829             *dir_ptr = 1;
830         } else {
831             pred = a;
832             *dir_ptr = 0;
833         }
834     }
835
836     /* update predictor */
837     *dc_val_ptr = &dc_val[0];
838     return pred;
839 }
840
841 #define DC_MAX 119
842
843 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
844 {
845     int sign, code;
846     int pred, extquant;
847     int extrabits = 0;
848
849     if(s->msmpeg4_version==1){
850         int32_t *dc_val;
851         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
852
853         /* update predictor */
854         *dc_val= level;
855     }else{
856         int16_t *dc_val;
857         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
858
859         /* update predictor */
860         if (n < 4) {
861             *dc_val = level * s->y_dc_scale;
862         } else {
863             *dc_val = level * s->c_dc_scale;
864         }
865     }
866
867     /* do the prediction */
868     level -= pred;
869
870     if(s->msmpeg4_version<=2){
871         if (n < 4) {
872             put_bits(&s->pb,
873                      v2_dc_lum_table[level+256][1],
874                      v2_dc_lum_table[level+256][0]);
875         }else{
876             put_bits(&s->pb,
877                      v2_dc_chroma_table[level+256][1],
878                      v2_dc_chroma_table[level+256][0]);
879         }
880     }else{
881         sign = 0;
882         if (level < 0) {
883             level = -level;
884             sign = 1;
885         }
886         code = level;
887         if (code > DC_MAX)
888             code = DC_MAX;
889         else if( s->msmpeg4_version>=6 ) {
890             if( s->qscale == 1 ) {
891                 extquant = (level + 3) & 0x3;
892                 code  = ((level+3)>>2);
893             } else if( s->qscale == 2 ) {
894                 extquant = (level + 1) & 0x1;
895                 code  = ((level+1)>>1);
896             }
897         }
898
899         if (s->dc_table_index == 0) {
900             if (n < 4) {
901                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
902             } else {
903                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
904             }
905         } else {
906             if (n < 4) {
907                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
908             } else {
909                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
910             }
911         }
912
913         if(s->msmpeg4_version>=6 && s->qscale<=2)
914             extrabits = 3 - s->qscale;
915
916         if (code == DC_MAX)
917             put_bits(&s->pb, 8 + extrabits, level);
918         else if(extrabits > 0)//== VC1 && s->qscale<=2
919             put_bits(&s->pb, extrabits, extquant);
920
921         if (level != 0) {
922             put_bits(&s->pb, 1, sign);
923         }
924     }
925 }
926
927 /* Encoding of a block. Very similar to MPEG4 except for a different
928    escape coding (same as H263) and more vlc tables.
929  */
930 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
931 {
932     int level, run, last, i, j, last_index;
933     int last_non_zero, sign, slevel;
934     int code, run_diff, dc_pred_dir;
935     const RLTable *rl;
936     const uint8_t *scantable;
937
938     if (s->mb_intra) {
939         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
940         i = 1;
941         if (n < 4) {
942             rl = &rl_table[s->rl_table_index];
943         } else {
944             rl = &rl_table[3 + s->rl_chroma_table_index];
945         }
946         run_diff = s->msmpeg4_version>=4;
947         scantable= s->intra_scantable.permutated;
948     } else {
949         i = 0;
950         rl = &rl_table[3 + s->rl_table_index];
951         if(s->msmpeg4_version<=2)
952             run_diff = 0;
953         else
954             run_diff = 1;
955         scantable= s->inter_scantable.permutated;
956     }
957
958     /* recalculate block_last_index for M$ wmv1 */
959     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
960         for(last_index=63; last_index>=0; last_index--){
961             if(block[scantable[last_index]]) break;
962         }
963         s->block_last_index[n]= last_index;
964     }else
965         last_index = s->block_last_index[n];
966     /* AC coefs */
967     last_non_zero = i - 1;
968     for (; i <= last_index; i++) {
969         j = scantable[i];
970         level = block[j];
971         if (level) {
972             run = i - last_non_zero - 1;
973             last = (i == last_index);
974             sign = 0;
975             slevel = level;
976             if (level < 0) {
977                 sign = 1;
978                 level = -level;
979             }
980
981             if(level<=MAX_LEVEL && run<=MAX_RUN){
982                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
983             }
984
985             s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
986
987             code = get_rl_index(rl, last, run, level);
988             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
989             if (code == rl->n) {
990                 int level1, run1;
991
992                 level1 = level - rl->max_level[last][run];
993                 if (level1 < 1)
994                     goto esc2;
995                 code = get_rl_index(rl, last, run, level1);
996                 if (code == rl->n) {
997                 esc2:
998                     put_bits(&s->pb, 1, 0);
999                     if (level > MAX_LEVEL)
1000                         goto esc3;
1001                     run1 = run - rl->max_run[last][level] - run_diff;
1002                     if (run1 < 0)
1003                         goto esc3;
1004                     code = get_rl_index(rl, last, run1+1, level);
1005                     if (s->msmpeg4_version == 4 && code == rl->n)
1006                         goto esc3;
1007                     code = get_rl_index(rl, last, run1, level);
1008                     if (code == rl->n) {
1009                     esc3:
1010                         /* third escape */
1011                         put_bits(&s->pb, 1, 0);
1012                         put_bits(&s->pb, 1, last);
1013                         if(s->msmpeg4_version>=4){
1014                             if(s->esc3_level_length==0){
1015                                 s->esc3_level_length=8;
1016                                 s->esc3_run_length= 6;
1017                                 //ESCLVLSZ + ESCRUNSZ
1018                                 if(s->qscale<8)
1019                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1020                                 else
1021                                     put_bits(&s->pb, 8, 3);
1022                             }
1023                             put_bits(&s->pb, s->esc3_run_length, run);
1024                             put_bits(&s->pb, 1, sign);
1025                             put_bits(&s->pb, s->esc3_level_length, level);
1026                         }else{
1027                             put_bits(&s->pb, 6, run);
1028                             put_sbits(&s->pb, 8, slevel);
1029                         }
1030                     } else {
1031                         /* second escape */
1032                         put_bits(&s->pb, 1, 1);
1033                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1034                         put_bits(&s->pb, 1, sign);
1035                     }
1036                 } else {
1037                     /* first escape */
1038                     put_bits(&s->pb, 1, 1);
1039                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1040                     put_bits(&s->pb, 1, sign);
1041                 }
1042             } else {
1043                 put_bits(&s->pb, 1, sign);
1044             }
1045             last_non_zero = i;
1046         }
1047     }
1048 }
1049
1050 /****************************************/
1051 /* decoding stuff */
1052
1053 VLC ff_mb_non_intra_vlc[4];
1054 static VLC v2_dc_lum_vlc;
1055 static VLC v2_dc_chroma_vlc;
1056 static VLC v2_intra_cbpc_vlc;
1057 static VLC v2_mb_type_vlc;
1058 static VLC v2_mv_vlc;
1059 VLC ff_inter_intra_vlc;
1060
1061 /* This is identical to h263 except that its range is multiplied by 2. */
1062 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1063 {
1064     int code, val, sign, shift;
1065
1066     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1067 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1068     if (code < 0)
1069         return 0xffff;
1070
1071     if (code == 0)
1072         return pred;
1073     sign = get_bits1(&s->gb);
1074     shift = f_code - 1;
1075     val = code;
1076     if (shift) {
1077         val = (val - 1) << shift;
1078         val |= get_bits(&s->gb, shift);
1079         val++;
1080     }
1081     if (sign)
1082         val = -val;
1083
1084     val += pred;
1085     if (val <= -64)
1086         val += 64;
1087     else if (val >= 64)
1088         val -= 64;
1089
1090     return val;
1091 }
1092
1093 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1094 {
1095     int cbp, code, i;
1096
1097     if (s->pict_type == FF_P_TYPE) {
1098         if (s->use_skip_mb_code) {
1099             if (get_bits1(&s->gb)) {
1100                 /* skip mb */
1101                 s->mb_intra = 0;
1102                 for(i=0;i<6;i++)
1103                     s->block_last_index[i] = -1;
1104                 s->mv_dir = MV_DIR_FORWARD;
1105                 s->mv_type = MV_TYPE_16X16;
1106                 s->mv[0][0][0] = 0;
1107                 s->mv[0][0][1] = 0;
1108                 s->mb_skipped = 1;
1109                 return 0;
1110             }
1111         }
1112
1113         if(s->msmpeg4_version==2)
1114             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1115         else
1116             code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1117         if(code<0 || code>7){
1118             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1119             return -1;
1120         }
1121
1122         s->mb_intra = code >>2;
1123
1124         cbp = code & 0x3;
1125     } else {
1126         s->mb_intra = 1;
1127         if(s->msmpeg4_version==2)
1128             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1129         else
1130             cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1131         if(cbp<0 || cbp>3){
1132             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1133             return -1;
1134         }
1135     }
1136
1137     if (!s->mb_intra) {
1138         int mx, my, cbpy;
1139
1140         cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1141         if(cbpy<0){
1142             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1143             return -1;
1144         }
1145
1146         cbp|= cbpy<<2;
1147         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1148
1149         h263_pred_motion(s, 0, 0, &mx, &my);
1150         mx= msmpeg4v2_decode_motion(s, mx, 1);
1151         my= msmpeg4v2_decode_motion(s, my, 1);
1152
1153         s->mv_dir = MV_DIR_FORWARD;
1154         s->mv_type = MV_TYPE_16X16;
1155         s->mv[0][0][0] = mx;
1156         s->mv[0][0][1] = my;
1157     } else {
1158         if(s->msmpeg4_version==2){
1159             s->ac_pred = get_bits1(&s->gb);
1160             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1161         } else{
1162             s->ac_pred = 0;
1163             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1164             if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1165         }
1166     }
1167
1168     s->dsp.clear_blocks(s->block[0]);
1169     for (i = 0; i < 6; i++) {
1170         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1171         {
1172              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1173              return -1;
1174         }
1175     }
1176     return 0;
1177 }
1178
1179 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1180 {
1181     int cbp, code, i;
1182     uint8_t *coded_val;
1183     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1184
1185     if (s->pict_type == FF_P_TYPE) {
1186         if (s->use_skip_mb_code) {
1187             if (get_bits1(&s->gb)) {
1188                 /* skip mb */
1189                 s->mb_intra = 0;
1190                 for(i=0;i<6;i++)
1191                     s->block_last_index[i] = -1;
1192                 s->mv_dir = MV_DIR_FORWARD;
1193                 s->mv_type = MV_TYPE_16X16;
1194                 s->mv[0][0][0] = 0;
1195                 s->mv[0][0][1] = 0;
1196                 s->mb_skipped = 1;
1197                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1198
1199                 return 0;
1200             }
1201         }
1202
1203         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1204         if (code < 0)
1205             return -1;
1206         //s->mb_intra = (code & 0x40) ? 0 : 1;
1207         s->mb_intra = (~code & 0x40) >> 6;
1208
1209         cbp = code & 0x3f;
1210     } else {
1211         s->mb_intra = 1;
1212         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1213         if (code < 0)
1214             return -1;
1215         /* predict coded block pattern */
1216         cbp = 0;
1217         for(i=0;i<6;i++) {
1218             int val = ((code >> (5 - i)) & 1);
1219             if (i < 4) {
1220                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1221                 val = val ^ pred;
1222                 *coded_val = val;
1223             }
1224             cbp |= val << (5 - i);
1225         }
1226     }
1227
1228     if (!s->mb_intra) {
1229         int mx, my;
1230 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1231         if(s->per_mb_rl_table && cbp){
1232             s->rl_table_index = decode012(&s->gb);
1233             s->rl_chroma_table_index = s->rl_table_index;
1234         }
1235         h263_pred_motion(s, 0, 0, &mx, &my);
1236         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1237             return -1;
1238         s->mv_dir = MV_DIR_FORWARD;
1239         s->mv_type = MV_TYPE_16X16;
1240         s->mv[0][0][0] = mx;
1241         s->mv[0][0][1] = my;
1242         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1243     } else {
1244 //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));
1245         s->ac_pred = get_bits1(&s->gb);
1246         *mb_type_ptr = MB_TYPE_INTRA;
1247         if(s->inter_intra_pred){
1248             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1249 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1250         }
1251         if(s->per_mb_rl_table && cbp){
1252             s->rl_table_index = decode012(&s->gb);
1253             s->rl_chroma_table_index = s->rl_table_index;
1254         }
1255     }
1256
1257     s->dsp.clear_blocks(s->block[0]);
1258     for (i = 0; i < 6; i++) {
1259         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1260         {
1261             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1262             return -1;
1263         }
1264     }
1265
1266     return 0;
1267 }
1268
1269 /* init all vlc decoding tables */
1270 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1271 {
1272     MpegEncContext *s = avctx->priv_data;
1273     static int done = 0;
1274     int i;
1275     MVTable *mv;
1276
1277     if (ff_h263_decode_init(avctx) < 0)
1278         return -1;
1279
1280     common_init(s);
1281
1282     if (!done) {
1283         done = 1;
1284
1285         for(i=0;i<NB_RL_TABLES;i++) {
1286             init_rl(&rl_table[i], static_rl_table_store[i]);
1287         }
1288         INIT_VLC_RL(rl_table[0], 642);
1289         INIT_VLC_RL(rl_table[1], 1104);
1290         INIT_VLC_RL(rl_table[2], 554);
1291         INIT_VLC_RL(rl_table[3], 940);
1292         INIT_VLC_RL(rl_table[4], 962);
1293         INIT_VLC_RL(rl_table[5], 554);
1294
1295         mv = &mv_tables[0];
1296         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1297                     mv->table_mv_bits, 1, 1,
1298                     mv->table_mv_code, 2, 2, 3714);
1299         mv = &mv_tables[1];
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, 2694);
1303
1304         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1305                  &ff_table0_dc_lum[0][1], 8, 4,
1306                  &ff_table0_dc_lum[0][0], 8, 4, 1158);
1307         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1308                  &ff_table0_dc_chroma[0][1], 8, 4,
1309                  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1310         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1311                  &ff_table1_dc_lum[0][1], 8, 4,
1312                  &ff_table1_dc_lum[0][0], 8, 4, 1476);
1313         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1314                  &ff_table1_dc_chroma[0][1], 8, 4,
1315                  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1316
1317         INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1318                  &v2_dc_lum_table[0][1], 8, 4,
1319                  &v2_dc_lum_table[0][0], 8, 4, 1472);
1320         INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1321                  &v2_dc_chroma_table[0][1], 8, 4,
1322                  &v2_dc_chroma_table[0][0], 8, 4, 1506);
1323
1324         INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1325                  &v2_intra_cbpc[0][1], 2, 1,
1326                  &v2_intra_cbpc[0][0], 2, 1, 8);
1327         INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1328                  &v2_mb_type[0][1], 2, 1,
1329                  &v2_mb_type[0][0], 2, 1, 128);
1330         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1331                  &mvtab[0][1], 2, 1,
1332                  &mvtab[0][0], 2, 1, 538);
1333
1334         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1335                      &wmv2_inter_table[0][0][1], 8, 4,
1336                      &wmv2_inter_table[0][0][0], 8, 4, 1636);
1337         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1338                      &wmv2_inter_table[1][0][1], 8, 4,
1339                      &wmv2_inter_table[1][0][0], 8, 4, 2648);
1340         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1341                      &wmv2_inter_table[2][0][1], 8, 4,
1342                      &wmv2_inter_table[2][0][0], 8, 4, 1532);
1343         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1344                      &wmv2_inter_table[3][0][1], 8, 4,
1345                      &wmv2_inter_table[3][0][0], 8, 4, 2488);
1346
1347         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1348                  &ff_msmp4_mb_i_table[0][1], 4, 2,
1349                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1350
1351         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1352                  &table_inter_intra[0][1], 2, 1,
1353                  &table_inter_intra[0][0], 2, 1, 8);
1354     }
1355
1356     switch(s->msmpeg4_version){
1357     case 1:
1358     case 2:
1359         s->decode_mb= msmpeg4v12_decode_mb;
1360         break;
1361     case 3:
1362     case 4:
1363         s->decode_mb= msmpeg4v34_decode_mb;
1364         break;
1365     case 5:
1366         if (CONFIG_WMV2_DECODER)
1367             s->decode_mb= ff_wmv2_decode_mb;
1368     case 6:
1369         //FIXME + TODO VC1 decode mb
1370         break;
1371     }
1372
1373     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1374
1375     return 0;
1376 }
1377
1378 int msmpeg4_decode_picture_header(MpegEncContext * s)
1379 {
1380     int code;
1381
1382     if(s->msmpeg4_version==1){
1383         int start_code = get_bits_long(&s->gb, 32);
1384         if(start_code!=0x00000100){
1385             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1386             return -1;
1387         }
1388
1389         skip_bits(&s->gb, 5); // frame number */
1390     }
1391
1392     s->pict_type = get_bits(&s->gb, 2) + 1;
1393     if (s->pict_type != FF_I_TYPE &&
1394         s->pict_type != FF_P_TYPE){
1395         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1396         return -1;
1397     }
1398 #if 0
1399 {
1400     static int had_i=0;
1401     if(s->pict_type == FF_I_TYPE) had_i=1;
1402     if(!had_i) return -1;
1403 }
1404 #endif
1405     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1406     if(s->qscale==0){
1407         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1408         return -1;
1409     }
1410
1411     if (s->pict_type == FF_I_TYPE) {
1412         code = get_bits(&s->gb, 5);
1413         if(s->msmpeg4_version==1){
1414             if(code==0 || code>s->mb_height){
1415                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1416                 return -1;
1417             }
1418
1419             s->slice_height = code;
1420         }else{
1421             /* 0x17: one slice, 0x18: two slices, ... */
1422             if (code < 0x17){
1423                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1424                 return -1;
1425             }
1426
1427             s->slice_height = s->mb_height / (code - 0x16);
1428         }
1429
1430         switch(s->msmpeg4_version){
1431         case 1:
1432         case 2:
1433             s->rl_chroma_table_index = 2;
1434             s->rl_table_index = 2;
1435
1436             s->dc_table_index = 0; //not used
1437             break;
1438         case 3:
1439             s->rl_chroma_table_index = decode012(&s->gb);
1440             s->rl_table_index = decode012(&s->gb);
1441
1442             s->dc_table_index = get_bits1(&s->gb);
1443             break;
1444         case 4:
1445             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1446
1447             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1448             else                           s->per_mb_rl_table= 0;
1449
1450             if(!s->per_mb_rl_table){
1451                 s->rl_chroma_table_index = decode012(&s->gb);
1452                 s->rl_table_index = decode012(&s->gb);
1453             }
1454
1455             s->dc_table_index = get_bits1(&s->gb);
1456             s->inter_intra_pred= 0;
1457             break;
1458         }
1459         s->no_rounding = 1;
1460         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1461             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1462                 s->qscale,
1463                 s->rl_chroma_table_index,
1464                 s->rl_table_index,
1465                 s->dc_table_index,
1466                 s->per_mb_rl_table,
1467                 s->slice_height);
1468     } else {
1469         switch(s->msmpeg4_version){
1470         case 1:
1471         case 2:
1472             if(s->msmpeg4_version==1)
1473                 s->use_skip_mb_code = 1;
1474             else
1475                 s->use_skip_mb_code = get_bits1(&s->gb);
1476             s->rl_table_index = 2;
1477             s->rl_chroma_table_index = s->rl_table_index;
1478             s->dc_table_index = 0; //not used
1479             s->mv_table_index = 0;
1480             break;
1481         case 3:
1482             s->use_skip_mb_code = get_bits1(&s->gb);
1483             s->rl_table_index = decode012(&s->gb);
1484             s->rl_chroma_table_index = s->rl_table_index;
1485
1486             s->dc_table_index = get_bits1(&s->gb);
1487
1488             s->mv_table_index = get_bits1(&s->gb);
1489             break;
1490         case 4:
1491             s->use_skip_mb_code = get_bits1(&s->gb);
1492
1493             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1494             else                           s->per_mb_rl_table= 0;
1495
1496             if(!s->per_mb_rl_table){
1497                 s->rl_table_index = decode012(&s->gb);
1498                 s->rl_chroma_table_index = s->rl_table_index;
1499             }
1500
1501             s->dc_table_index = get_bits1(&s->gb);
1502
1503             s->mv_table_index = get_bits1(&s->gb);
1504             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1505             break;
1506         }
1507
1508         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1509             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1510                 s->use_skip_mb_code,
1511                 s->rl_table_index,
1512                 s->rl_chroma_table_index,
1513                 s->dc_table_index,
1514                 s->mv_table_index,
1515                 s->per_mb_rl_table,
1516                 s->qscale);
1517
1518         if(s->flipflop_rounding){
1519             s->no_rounding ^= 1;
1520         }else{
1521             s->no_rounding = 0;
1522         }
1523     }
1524 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1525
1526     s->esc3_level_length= 0;
1527     s->esc3_run_length= 0;
1528
1529     return 0;
1530 }
1531
1532 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1533 {
1534     int left= buf_size*8 - get_bits_count(&s->gb);
1535     int length= s->msmpeg4_version>=3 ? 17 : 16;
1536     /* the alt_bitstream reader could read over the end so we need to check it */
1537     if(left>=length && left<length+8)
1538     {
1539         int fps;
1540
1541         fps= get_bits(&s->gb, 5);
1542         s->bit_rate= get_bits(&s->gb, 11)*1024;
1543         if(s->msmpeg4_version>=3)
1544             s->flipflop_rounding= get_bits1(&s->gb);
1545         else
1546             s->flipflop_rounding= 0;
1547
1548 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1549     }
1550     else if(left<length+8)
1551     {
1552         s->flipflop_rounding= 0;
1553         if(s->msmpeg4_version != 2)
1554             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1555     }
1556     else
1557     {
1558         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1559     }
1560
1561     return 0;
1562 }
1563
1564 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1565 {
1566     int level, pred;
1567
1568     if(s->msmpeg4_version<=2){
1569         if (n < 4) {
1570             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1571         } else {
1572             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1573         }
1574         if (level < 0)
1575             return -1;
1576         level-=256;
1577     }else{  //FIXME optimize use unified tables & index
1578         if (n < 4) {
1579             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1580         } else {
1581             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1582         }
1583         if (level < 0){
1584             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1585             return -1;
1586         }
1587
1588         if (level == DC_MAX) {
1589             level = get_bits(&s->gb, 8);
1590             if (get_bits1(&s->gb))
1591                 level = -level;
1592         } else if (level != 0) {
1593             if (get_bits1(&s->gb))
1594                 level = -level;
1595         }
1596     }
1597
1598     if(s->msmpeg4_version==1){
1599         int32_t *dc_val;
1600         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1601         level += pred;
1602
1603         /* update predictor */
1604         *dc_val= level;
1605     }else{
1606         int16_t *dc_val;
1607         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1608         level += pred;
1609
1610         /* update predictor */
1611         if (n < 4) {
1612             *dc_val = level * s->y_dc_scale;
1613         } else {
1614             *dc_val = level * s->c_dc_scale;
1615         }
1616     }
1617
1618     return level;
1619 }
1620
1621 //#define ERROR_DETAILS
1622 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1623                               int n, int coded, const uint8_t *scan_table)
1624 {
1625     int level, i, last, run, run_diff;
1626     int av_uninit(dc_pred_dir);
1627     RLTable *rl;
1628     RL_VLC_ELEM *rl_vlc;
1629     int qmul, qadd;
1630
1631     if (s->mb_intra) {
1632         qmul=1;
1633         qadd=0;
1634
1635         /* DC coef */
1636         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1637
1638         if (level < 0){
1639             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1640             if(s->inter_intra_pred) level=0;
1641             else                    return -1;
1642         }
1643         if (n < 4) {
1644             rl = &rl_table[s->rl_table_index];
1645             if(level > 256*s->y_dc_scale){
1646                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1647                 if(!s->inter_intra_pred) return -1;
1648             }
1649         } else {
1650             rl = &rl_table[3 + s->rl_chroma_table_index];
1651             if(level > 256*s->c_dc_scale){
1652                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1653                 if(!s->inter_intra_pred) return -1;
1654             }
1655         }
1656         block[0] = level;
1657
1658         run_diff = s->msmpeg4_version >= 4;
1659         i = 0;
1660         if (!coded) {
1661             goto not_coded;
1662         }
1663         if (s->ac_pred) {
1664             if (dc_pred_dir == 0)
1665                 scan_table = s->intra_v_scantable.permutated; /* left */
1666             else
1667                 scan_table = s->intra_h_scantable.permutated; /* top */
1668         } else {
1669             scan_table = s->intra_scantable.permutated;
1670         }
1671         rl_vlc= rl->rl_vlc[0];
1672     } else {
1673         qmul = s->qscale << 1;
1674         qadd = (s->qscale - 1) | 1;
1675         i = -1;
1676         rl = &rl_table[3 + s->rl_table_index];
1677
1678         if(s->msmpeg4_version==2)
1679             run_diff = 0;
1680         else
1681             run_diff = 1;
1682
1683         if (!coded) {
1684             s->block_last_index[n] = i;
1685             return 0;
1686         }
1687         if(!scan_table)
1688             scan_table = s->inter_scantable.permutated;
1689         rl_vlc= rl->rl_vlc[s->qscale];
1690     }
1691   {
1692     OPEN_READER(re, &s->gb);
1693     for(;;) {
1694         UPDATE_CACHE(re, &s->gb);
1695         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1696         if (level==0) {
1697             int cache;
1698             cache= GET_CACHE(re, &s->gb);
1699             /* escape */
1700             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1701                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1702                     /* third escape */
1703                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1704                     UPDATE_CACHE(re, &s->gb);
1705                     if(s->msmpeg4_version<=3){
1706                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1707                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1708                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1709                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1710                     }else{
1711                         int sign;
1712                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1713                         if(!s->esc3_level_length){
1714                             int ll;
1715                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1716                             if(s->qscale<8){
1717                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1718                                 if(ll==0){
1719                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1720                                 }
1721                             }else{
1722                                 ll=2;
1723                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1724                                     ll++;
1725                                     SKIP_BITS(re, &s->gb, 1);
1726                                 }
1727                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1728                             }
1729
1730                             s->esc3_level_length= ll;
1731                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1732 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1733                             UPDATE_CACHE(re, &s->gb);
1734                         }
1735                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1736                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1737
1738                         sign=  SHOW_UBITS(re, &s->gb, 1);
1739                         SKIP_BITS(re, &s->gb, 1);
1740
1741                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1742                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1743                         if(sign) level= -level;
1744                     }
1745 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1746 #if 0 // waste of time / this will detect very few errors
1747                     {
1748                         const int abs_level= FFABS(level);
1749                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1750                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1751                             if(abs_level <= rl->max_level[last][run]){
1752                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1753                                 return DECODING_AC_LOST;
1754                             }
1755                             if(abs_level <= rl->max_level[last][run]*2){
1756                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1757                                 return DECODING_AC_LOST;
1758                             }
1759                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1760                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1761                                 return DECODING_AC_LOST;
1762                             }
1763                         }
1764                     }
1765 #endif
1766                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1767                     if (level>0) level= level * qmul + qadd;
1768                     else         level= level * qmul - qadd;
1769 #if 0 // waste of time too :(
1770                     if(level>2048 || level<-2048){
1771                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1772                         return DECODING_AC_LOST;
1773                     }
1774 #endif
1775                     i+= run + 1;
1776                     if(last) i+=192;
1777 #ifdef ERROR_DETAILS
1778                 if(run==66)
1779                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1780                 else if((i>62 && i<192) || i>192+63)
1781                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1782 #endif
1783                 } else {
1784                     /* second escape */
1785                     SKIP_BITS(re, &s->gb, 2);
1786                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1787                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1788                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1789                     LAST_SKIP_BITS(re, &s->gb, 1);
1790 #ifdef ERROR_DETAILS
1791                 if(run==66)
1792                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1793                 else if((i>62 && i<192) || i>192+63)
1794                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1795 #endif
1796                 }
1797             } else {
1798                 /* first escape */
1799                 SKIP_BITS(re, &s->gb, 1);
1800                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1801                 i+= run;
1802                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//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 ESC1 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 ESC1 i=%d run=%d level=%d\n", i, run, level);
1810 #endif
1811             }
1812         } else {
1813             i+= run;
1814             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1815             LAST_SKIP_BITS(re, &s->gb, 1);
1816 #ifdef ERROR_DETAILS
1817                 if(run==66)
1818                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1819                 else if((i>62 && i<192) || i>192+63)
1820                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1821 #endif
1822         }
1823         if (i > 62){
1824             i-= 192;
1825             if(i&(~63)){
1826                 const int left= get_bits_left(&s->gb);
1827                 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1828                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1829                     break;
1830                 }else{
1831                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1832                     return -1;
1833                 }
1834             }
1835
1836             block[scan_table[i]] = level;
1837             break;
1838         }
1839
1840         block[scan_table[i]] = level;
1841     }
1842     CLOSE_READER(re, &s->gb);
1843   }
1844  not_coded:
1845     if (s->mb_intra) {
1846         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1847         if (s->ac_pred) {
1848             i = 63; /* XXX: not optimal */
1849         }
1850     }
1851     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1852     s->block_last_index[n] = i;
1853
1854     return 0;
1855 }
1856
1857 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1858                                  int *mx_ptr, int *my_ptr)
1859 {
1860     MVTable *mv;
1861     int code, mx, my;
1862
1863     mv = &mv_tables[s->mv_table_index];
1864
1865     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1866     if (code < 0){
1867         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1868         return -1;
1869     }
1870     if (code == mv->n) {
1871 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1872         mx = get_bits(&s->gb, 6);
1873         my = get_bits(&s->gb, 6);
1874     } else {
1875         mx = mv->table_mvx[code];
1876         my = mv->table_mvy[code];
1877     }
1878
1879     mx += *mx_ptr - 32;
1880     my += *my_ptr - 32;
1881     /* WARNING : they do not do exactly modulo encoding */
1882     if (mx <= -64)
1883         mx += 64;
1884     else if (mx >= 64)
1885         mx -= 64;
1886
1887     if (my <= -64)
1888         my += 64;
1889     else if (my >= 64)
1890         my -= 64;
1891     *mx_ptr = mx;
1892     *my_ptr = my;
1893     return 0;
1894 }
1895
1896 AVCodec ff_msmpeg4v1_decoder = {
1897     "msmpeg4v1",
1898     AVMEDIA_TYPE_VIDEO,
1899     CODEC_ID_MSMPEG4V1,
1900     sizeof(MpegEncContext),
1901     ff_msmpeg4_decode_init,
1902     NULL,
1903     ff_h263_decode_end,
1904     ff_h263_decode_frame,
1905     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
1906     .max_lowres= 3,
1907     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1908     .pix_fmts= ff_pixfmt_list_420,
1909 };
1910
1911 AVCodec ff_msmpeg4v2_decoder = {
1912     "msmpeg4v2",
1913     AVMEDIA_TYPE_VIDEO,
1914     CODEC_ID_MSMPEG4V2,
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 2"),
1923     .pix_fmts= ff_pixfmt_list_420,
1924 };
1925
1926 AVCodec ff_msmpeg4v3_decoder = {
1927     "msmpeg4",
1928     AVMEDIA_TYPE_VIDEO,
1929     CODEC_ID_MSMPEG4V3,
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 3"),
1938     .pix_fmts= ff_pixfmt_list_420,
1939 };
1940
1941 AVCodec ff_wmv1_decoder = {
1942     "wmv1",
1943     AVMEDIA_TYPE_VIDEO,
1944     CODEC_ID_WMV1,
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("Windows Media Video 7"),
1953     .pix_fmts= ff_pixfmt_list_420,
1954 };