msmpeg4dec: fix init code to not fail when called from 2 threads at the same time.
[ffmpeg.git] / libavcodec / msmpeg4.c
1 /*
2  * MSMPEG4 backend for 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 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/asm.h"
35 #include "h263.h"
36 #include "mpeg4video.h"
37 #include "msmpeg4data.h"
38 #include "vc1data.h"
39
40 /*
41  * You can also call this codec : MPEG4 with a twist !
42  *
43  * TODO:
44  *        - (encoding) select best mv table (two choices)
45  *        - (encoding) select best vlc/dc table
46  */
47 //#define DEBUG
48
49 #define DC_VLC_BITS 9
50 #define V2_INTRA_CBPC_VLC_BITS 3
51 #define V2_MB_TYPE_VLC_BITS 7
52 #define MV_VLC_BITS 9
53 #define V2_MV_VLC_BITS 9
54 #define TEX_VLC_BITS 9
55
56 #define DEFAULT_INTER_INDEX 3
57
58 /* This table is practically identical to the one from h263
59  * except that it is inverted. */
60 static av_cold void init_h263_dc_for_msmpeg4(void)
61 {
62         int level, uni_code, uni_len;
63
64         if(ff_v2_dc_chroma_table[255 + 256][1])
65             return;
66
67         for(level=-256; level<256; level++){
68             int size, v, l;
69             /* find number of bits */
70             size = 0;
71             v = abs(level);
72             while (v) {
73                 v >>= 1;
74                     size++;
75             }
76
77             if (level < 0)
78                 l= (-level) ^ ((1 << size) - 1);
79             else
80                 l= level;
81
82             /* luminance h263 */
83             uni_code= ff_mpeg4_DCtab_lum[size][0];
84             uni_len = ff_mpeg4_DCtab_lum[size][1];
85             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
86
87             if (size > 0) {
88                 uni_code<<=size; uni_code|=l;
89                 uni_len+=size;
90                 if (size > 8){
91                     uni_code<<=1; uni_code|=1;
92                     uni_len++;
93                 }
94             }
95             ff_v2_dc_lum_table[level + 256][0] = uni_code;
96             ff_v2_dc_lum_table[level + 256][1] = uni_len;
97
98             /* chrominance h263 */
99             uni_code= ff_mpeg4_DCtab_chrom[size][0];
100             uni_len = ff_mpeg4_DCtab_chrom[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             ff_v2_dc_chroma_table[level + 256][0] = uni_code;
112             ff_v2_dc_chroma_table[level + 256][1] = uni_len;
113
114         }
115 }
116
117 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
118 {
119     switch(s->msmpeg4_version){
120     case 1:
121     case 2:
122         s->y_dc_scale_table=
123         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
124         break;
125     case 3:
126         if(s->workaround_bugs){
127             s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
128             s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
129         } else{
130             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
131             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
132         }
133         break;
134     case 4:
135     case 5:
136         s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
137         s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
138         break;
139 #if CONFIG_VC1_DECODER
140     case 6:
141         s->y_dc_scale_table= ff_wmv3_dc_scale_table;
142         s->c_dc_scale_table= ff_wmv3_dc_scale_table;
143         break;
144 #endif
145
146     }
147
148
149     if(s->msmpeg4_version>=4){
150         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_wmv1_scantable[1]);
151         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
152         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
153         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_wmv1_scantable[0]);
154     }
155     //Note the default tables are set in common_init in mpegvideo.c
156
157     init_h263_dc_for_msmpeg4();
158 }
159
160 /* predict coded block */
161 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
162 {
163     int xy, wrap, pred, a, b, c;
164
165     xy = s->block_index[n];
166     wrap = s->b8_stride;
167
168     /* B C
169      * A X
170      */
171     a = s->coded_block[xy - 1       ];
172     b = s->coded_block[xy - 1 - wrap];
173     c = s->coded_block[xy     - wrap];
174
175     if (b == c) {
176         pred = a;
177     } else {
178         pred = c;
179     }
180
181     /* store value */
182     *coded_block_ptr = &s->coded_block[xy];
183
184     return pred;
185 }
186
187 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
188                                     int32_t **dc_val_ptr)
189 {
190     int i;
191
192     if (n < 4) {
193         i= 0;
194     } else {
195         i= n-3;
196     }
197
198     *dc_val_ptr= &s->last_dc[i];
199     return s->last_dc[i];
200 }
201
202 static int get_dc(uint8_t *src, int stride, int scale)
203 {
204     int y;
205     int sum=0;
206     for(y=0; y<8; y++){
207         int x;
208         for(x=0; x<8; x++){
209             sum+=src[x + y*stride];
210         }
211     }
212     return FASTDIV((sum + (scale>>1)), scale);
213 }
214
215 /* dir = 0: left, dir = 1: top prediction */
216 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
217                        int16_t **dc_val_ptr, int *dir_ptr)
218 {
219     int a, b, c, wrap, pred, scale;
220     int16_t *dc_val;
221
222     /* find prediction */
223     if (n < 4) {
224         scale = s->y_dc_scale;
225     } else {
226         scale = s->c_dc_scale;
227     }
228
229     wrap = s->block_wrap[n];
230     dc_val= s->dc_val[0] + s->block_index[n];
231
232     /* B C
233      * A X
234      */
235     a = dc_val[ - 1];
236     b = dc_val[ - 1 - wrap];
237     c = dc_val[ - wrap];
238
239     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
240         b=c=1024;
241     }
242
243     /* XXX: the following solution consumes divisions, but it does not
244        necessitate to modify mpegvideo.c. The problem comes from the
245        fact they decided to store the quantized DC (which would lead
246        to problems if Q could vary !) */
247 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
248     __asm__ volatile(
249         "movl %3, %%eax         \n\t"
250         "shrl $1, %%eax         \n\t"
251         "addl %%eax, %2         \n\t"
252         "addl %%eax, %1         \n\t"
253         "addl %0, %%eax         \n\t"
254         "mull %4                \n\t"
255         "movl %%edx, %0         \n\t"
256         "movl %1, %%eax         \n\t"
257         "mull %4                \n\t"
258         "movl %%edx, %1         \n\t"
259         "movl %2, %%eax         \n\t"
260         "mull %4                \n\t"
261         "movl %%edx, %2         \n\t"
262         : "+b" (a), "+c" (b), "+D" (c)
263         : "g" (scale), "S" (ff_inverse[scale])
264         : "%eax", "%edx"
265     );
266 #else
267     /* #elif ARCH_ALPHA */
268     /* Divisions are extremely costly on Alpha; optimize the most
269        common case. But they are costly everywhere...
270      */
271     if (scale == 8) {
272         a = (a + (8 >> 1)) / 8;
273         b = (b + (8 >> 1)) / 8;
274         c = (c + (8 >> 1)) / 8;
275     } else {
276         a = FASTDIV((a + (scale >> 1)), scale);
277         b = FASTDIV((b + (scale >> 1)), scale);
278         c = FASTDIV((c + (scale >> 1)), scale);
279     }
280 #endif
281     /* XXX: WARNING: they did not choose the same test as MPEG4. This
282        is very important ! */
283     if(s->msmpeg4_version>3){
284         if(s->inter_intra_pred){
285             uint8_t *dest;
286             int wrap;
287
288             if(n==1){
289                 pred=a;
290                 *dir_ptr = 0;
291             }else if(n==2){
292                 pred=c;
293                 *dir_ptr = 1;
294             }else if(n==3){
295                 if (abs(a - b) < abs(b - c)) {
296                     pred = c;
297                     *dir_ptr = 1;
298                 } else {
299                     pred = a;
300                     *dir_ptr = 0;
301                 }
302             }else{
303                 if(n<4){
304                     wrap= s->linesize;
305                     dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8*  wrap ) + ((n & 1) + 2*s->mb_x) * 8;
306                 }else{
307                     wrap= s->uvlinesize;
308                     dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
309                 }
310                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
311                 else           a= get_dc(dest-8, wrap, scale*8);
312                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
313                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
314
315                 if (s->h263_aic_dir==0) {
316                     pred= a;
317                     *dir_ptr = 0;
318                 }else if (s->h263_aic_dir==1) {
319                     if(n==0){
320                         pred= c;
321                         *dir_ptr = 1;
322                     }else{
323                         pred= a;
324                         *dir_ptr = 0;
325                     }
326                 }else if (s->h263_aic_dir==2) {
327                     if(n==0){
328                         pred= a;
329                         *dir_ptr = 0;
330                     }else{
331                         pred= c;
332                         *dir_ptr = 1;
333                     }
334                 } else {
335                     pred= c;
336                     *dir_ptr = 1;
337                 }
338             }
339         }else{
340             if (abs(a - b) < abs(b - c)) {
341                 pred = c;
342                 *dir_ptr = 1;
343             } else {
344                 pred = a;
345                 *dir_ptr = 0;
346             }
347         }
348     }else{
349         if (abs(a - b) <= abs(b - c)) {
350             pred = c;
351             *dir_ptr = 1;
352         } else {
353             pred = a;
354             *dir_ptr = 0;
355         }
356     }
357
358     /* update predictor */
359     *dc_val_ptr = &dc_val[0];
360     return pred;
361 }
362
363 /****************************************/
364 /* decoding stuff */
365
366 VLC ff_mb_non_intra_vlc[4];
367 static VLC v2_dc_lum_vlc;
368 static VLC v2_dc_chroma_vlc;
369 static VLC v2_intra_cbpc_vlc;
370 static VLC v2_mb_type_vlc;
371 static VLC v2_mv_vlc;
372 VLC ff_inter_intra_vlc;
373
374 /* This is identical to h263 except that its range is multiplied by 2. */
375 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
376 {
377     int code, val, sign, shift;
378
379     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
380     av_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
381     if (code < 0)
382         return 0xffff;
383
384     if (code == 0)
385         return pred;
386     sign = get_bits1(&s->gb);
387     shift = f_code - 1;
388     val = code;
389     if (shift) {
390         val = (val - 1) << shift;
391         val |= get_bits(&s->gb, shift);
392         val++;
393     }
394     if (sign)
395         val = -val;
396
397     val += pred;
398     if (val <= -64)
399         val += 64;
400     else if (val >= 64)
401         val -= 64;
402
403     return val;
404 }
405
406 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
407 {
408     int cbp, code, i;
409     uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
410
411     if (s->pict_type == AV_PICTURE_TYPE_P) {
412         if (s->use_skip_mb_code) {
413             if (get_bits1(&s->gb)) {
414                 /* skip mb */
415                 s->mb_intra = 0;
416                 for(i=0;i<6;i++)
417                     s->block_last_index[i] = -1;
418                 s->mv_dir = MV_DIR_FORWARD;
419                 s->mv_type = MV_TYPE_16X16;
420                 s->mv[0][0][0] = 0;
421                 s->mv[0][0][1] = 0;
422                 s->mb_skipped = 1;
423                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
424                 return 0;
425             }
426         }
427
428         if(s->msmpeg4_version==2)
429             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
430         else
431             code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
432         if(code<0 || code>7){
433             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
434             return -1;
435         }
436
437         s->mb_intra = code >>2;
438
439         cbp = code & 0x3;
440     } else {
441         s->mb_intra = 1;
442         if(s->msmpeg4_version==2)
443             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
444         else
445             cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
446         if(cbp<0 || cbp>3){
447             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
448             return -1;
449         }
450     }
451
452     if (!s->mb_intra) {
453         int mx, my, cbpy;
454
455         cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
456         if(cbpy<0){
457             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
458             return -1;
459         }
460
461         cbp|= cbpy<<2;
462         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
463
464         ff_h263_pred_motion(s, 0, 0, &mx, &my);
465         mx= msmpeg4v2_decode_motion(s, mx, 1);
466         my= msmpeg4v2_decode_motion(s, my, 1);
467
468         s->mv_dir = MV_DIR_FORWARD;
469         s->mv_type = MV_TYPE_16X16;
470         s->mv[0][0][0] = mx;
471         s->mv[0][0][1] = my;
472         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
473     } else {
474         if(s->msmpeg4_version==2){
475             s->ac_pred = get_bits1(&s->gb);
476             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
477         } else{
478             s->ac_pred = 0;
479             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
480             if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
481         }
482         *mb_type_ptr = MB_TYPE_INTRA;
483     }
484
485     s->dsp.clear_blocks(s->block[0]);
486     for (i = 0; i < 6; i++) {
487         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
488         {
489              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
490              return -1;
491         }
492     }
493     return 0;
494 }
495
496 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
497 {
498     int cbp, code, i;
499     uint8_t *coded_val;
500     uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
501
502     if (s->pict_type == AV_PICTURE_TYPE_P) {
503         if (s->use_skip_mb_code) {
504             if (get_bits1(&s->gb)) {
505                 /* skip mb */
506                 s->mb_intra = 0;
507                 for(i=0;i<6;i++)
508                     s->block_last_index[i] = -1;
509                 s->mv_dir = MV_DIR_FORWARD;
510                 s->mv_type = MV_TYPE_16X16;
511                 s->mv[0][0][0] = 0;
512                 s->mv[0][0][1] = 0;
513                 s->mb_skipped = 1;
514                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
515
516                 return 0;
517             }
518         }
519
520         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
521         if (code < 0)
522             return -1;
523         //s->mb_intra = (code & 0x40) ? 0 : 1;
524         s->mb_intra = (~code & 0x40) >> 6;
525
526         cbp = code & 0x3f;
527     } else {
528         s->mb_intra = 1;
529         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
530         if (code < 0)
531             return -1;
532         /* predict coded block pattern */
533         cbp = 0;
534         for(i=0;i<6;i++) {
535             int val = ((code >> (5 - i)) & 1);
536             if (i < 4) {
537                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
538                 val = val ^ pred;
539                 *coded_val = val;
540             }
541             cbp |= val << (5 - i);
542         }
543     }
544
545     if (!s->mb_intra) {
546         int mx, my;
547         if(s->per_mb_rl_table && cbp){
548             s->rl_table_index = decode012(&s->gb);
549             s->rl_chroma_table_index = s->rl_table_index;
550         }
551         ff_h263_pred_motion(s, 0, 0, &mx, &my);
552         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
553             return -1;
554         s->mv_dir = MV_DIR_FORWARD;
555         s->mv_type = MV_TYPE_16X16;
556         s->mv[0][0][0] = mx;
557         s->mv[0][0][1] = my;
558         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
559     } else {
560         av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
561                 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
562                 show_bits(&s->gb, 24));
563         s->ac_pred = get_bits1(&s->gb);
564         *mb_type_ptr = MB_TYPE_INTRA;
565         if(s->inter_intra_pred){
566             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
567             av_dlog(s, "%d%d %d %d/",
568                     s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
569         }
570         if(s->per_mb_rl_table && cbp){
571             s->rl_table_index = decode012(&s->gb);
572             s->rl_chroma_table_index = s->rl_table_index;
573         }
574     }
575
576     s->dsp.clear_blocks(s->block[0]);
577     for (i = 0; i < 6; i++) {
578         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
579         {
580             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
581             return -1;
582         }
583     }
584
585     return 0;
586 }
587
588 /* init all vlc decoding tables */
589 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
590 {
591     MpegEncContext *s = avctx->priv_data;
592     static volatile int done = 0;
593     int i;
594     MVTable *mv;
595
596     if (ff_h263_decode_init(avctx) < 0)
597         return -1;
598
599     ff_msmpeg4_common_init(s);
600
601     if (!done) {
602         for(i=0;i<NB_RL_TABLES;i++) {
603             ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
604         }
605         INIT_VLC_RL(ff_rl_table[0], 642);
606         INIT_VLC_RL(ff_rl_table[1], 1104);
607         INIT_VLC_RL(ff_rl_table[2], 554);
608         INIT_VLC_RL(ff_rl_table[3], 940);
609         INIT_VLC_RL(ff_rl_table[4], 962);
610         INIT_VLC_RL(ff_rl_table[5], 554);
611
612         mv = &ff_mv_tables[0];
613         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
614                     mv->table_mv_bits, 1, 1,
615                     mv->table_mv_code, 2, 2, 3714);
616         mv = &ff_mv_tables[1];
617         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
618                     mv->table_mv_bits, 1, 1,
619                     mv->table_mv_code, 2, 2, 2694);
620
621         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
622                  &ff_table0_dc_lum[0][1], 8, 4,
623                  &ff_table0_dc_lum[0][0], 8, 4, 1158);
624         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
625                  &ff_table0_dc_chroma[0][1], 8, 4,
626                  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
627         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
628                  &ff_table1_dc_lum[0][1], 8, 4,
629                  &ff_table1_dc_lum[0][0], 8, 4, 1476);
630         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
631                  &ff_table1_dc_chroma[0][1], 8, 4,
632                  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
633
634         INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
635                  &ff_v2_dc_lum_table[0][1], 8, 4,
636                  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
637         INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
638                  &ff_v2_dc_chroma_table[0][1], 8, 4,
639                  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
640
641         INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
642                  &ff_v2_intra_cbpc[0][1], 2, 1,
643                  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
644         INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
645                  &ff_v2_mb_type[0][1], 2, 1,
646                  &ff_v2_mb_type[0][0], 2, 1, 128);
647         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
648                  &ff_mvtab[0][1], 2, 1,
649                  &ff_mvtab[0][0], 2, 1, 538);
650
651         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
652                      &ff_wmv2_inter_table[0][0][1], 8, 4,
653                      &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
654         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
655                      &ff_wmv2_inter_table[1][0][1], 8, 4,
656                      &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
657         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
658                      &ff_wmv2_inter_table[2][0][1], 8, 4,
659                      &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
660         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
661                      &ff_wmv2_inter_table[3][0][1], 8, 4,
662                      &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
663
664         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
665                  &ff_msmp4_mb_i_table[0][1], 4, 2,
666                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
667
668         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
669                  &ff_table_inter_intra[0][1], 2, 1,
670                  &ff_table_inter_intra[0][0], 2, 1, 8);
671         done = 1;
672     }
673
674     switch(s->msmpeg4_version){
675     case 1:
676     case 2:
677         s->decode_mb= msmpeg4v12_decode_mb;
678         break;
679     case 3:
680     case 4:
681         s->decode_mb= msmpeg4v34_decode_mb;
682         break;
683     case 5:
684         if (CONFIG_WMV2_DECODER)
685             s->decode_mb= ff_wmv2_decode_mb;
686     case 6:
687         //FIXME + TODO VC1 decode mb
688         break;
689     }
690
691     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
692
693     return 0;
694 }
695
696 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
697 {
698     int code;
699
700     if(s->msmpeg4_version==1){
701         int start_code = get_bits_long(&s->gb, 32);
702         if(start_code!=0x00000100){
703             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
704             return -1;
705         }
706
707         skip_bits(&s->gb, 5); // frame number */
708     }
709
710     s->pict_type = get_bits(&s->gb, 2) + 1;
711     if (s->pict_type != AV_PICTURE_TYPE_I &&
712         s->pict_type != AV_PICTURE_TYPE_P){
713         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
714         return -1;
715     }
716 #if 0
717 {
718     static int had_i=0;
719     if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
720     if(!had_i) return -1;
721 }
722 #endif
723     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
724     if(s->qscale==0){
725         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
726         return -1;
727     }
728
729     if (s->pict_type == AV_PICTURE_TYPE_I) {
730         code = get_bits(&s->gb, 5);
731         if(s->msmpeg4_version==1){
732             if(code==0 || code>s->mb_height){
733                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
734                 return -1;
735             }
736
737             s->slice_height = code;
738         }else{
739             /* 0x17: one slice, 0x18: two slices, ... */
740             if (code < 0x17){
741                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
742                 return -1;
743             }
744
745             s->slice_height = s->mb_height / (code - 0x16);
746         }
747
748         switch(s->msmpeg4_version){
749         case 1:
750         case 2:
751             s->rl_chroma_table_index = 2;
752             s->rl_table_index = 2;
753
754             s->dc_table_index = 0; //not used
755             break;
756         case 3:
757             s->rl_chroma_table_index = decode012(&s->gb);
758             s->rl_table_index = decode012(&s->gb);
759
760             s->dc_table_index = get_bits1(&s->gb);
761             break;
762         case 4:
763             ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
764
765             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
766             else                           s->per_mb_rl_table= 0;
767
768             if(!s->per_mb_rl_table){
769                 s->rl_chroma_table_index = decode012(&s->gb);
770                 s->rl_table_index = decode012(&s->gb);
771             }
772
773             s->dc_table_index = get_bits1(&s->gb);
774             s->inter_intra_pred= 0;
775             break;
776         }
777         s->no_rounding = 1;
778         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
779             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
780                 s->qscale,
781                 s->rl_chroma_table_index,
782                 s->rl_table_index,
783                 s->dc_table_index,
784                 s->per_mb_rl_table,
785                 s->slice_height);
786     } else {
787         switch(s->msmpeg4_version){
788         case 1:
789         case 2:
790             if(s->msmpeg4_version==1)
791                 s->use_skip_mb_code = 1;
792             else
793                 s->use_skip_mb_code = get_bits1(&s->gb);
794             s->rl_table_index = 2;
795             s->rl_chroma_table_index = s->rl_table_index;
796             s->dc_table_index = 0; //not used
797             s->mv_table_index = 0;
798             break;
799         case 3:
800             s->use_skip_mb_code = get_bits1(&s->gb);
801             s->rl_table_index = decode012(&s->gb);
802             s->rl_chroma_table_index = s->rl_table_index;
803
804             s->dc_table_index = get_bits1(&s->gb);
805
806             s->mv_table_index = get_bits1(&s->gb);
807             break;
808         case 4:
809             s->use_skip_mb_code = get_bits1(&s->gb);
810
811             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
812             else                           s->per_mb_rl_table= 0;
813
814             if(!s->per_mb_rl_table){
815                 s->rl_table_index = decode012(&s->gb);
816                 s->rl_chroma_table_index = s->rl_table_index;
817             }
818
819             s->dc_table_index = get_bits1(&s->gb);
820
821             s->mv_table_index = get_bits1(&s->gb);
822             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
823             break;
824         }
825
826         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
827             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
828                 s->use_skip_mb_code,
829                 s->rl_table_index,
830                 s->rl_chroma_table_index,
831                 s->dc_table_index,
832                 s->mv_table_index,
833                 s->per_mb_rl_table,
834                 s->qscale);
835
836         if(s->flipflop_rounding){
837             s->no_rounding ^= 1;
838         }else{
839             s->no_rounding = 0;
840         }
841     }
842     av_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
843             s->inter_intra_pred, s->width, s->height);
844
845     s->esc3_level_length= 0;
846     s->esc3_run_length= 0;
847
848     return 0;
849 }
850
851 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
852 {
853     int left= buf_size*8 - get_bits_count(&s->gb);
854     int length= s->msmpeg4_version>=3 ? 17 : 16;
855     /* the alt_bitstream reader could read over the end so we need to check it */
856     if(left>=length && left<length+8)
857     {
858         skip_bits(&s->gb, 5); /* fps */
859         s->bit_rate= get_bits(&s->gb, 11)*1024;
860         if(s->msmpeg4_version>=3)
861             s->flipflop_rounding= get_bits1(&s->gb);
862         else
863             s->flipflop_rounding= 0;
864     }
865     else if(left<length+8)
866     {
867         s->flipflop_rounding= 0;
868         if(s->msmpeg4_version != 2)
869             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
870     }
871     else
872     {
873         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
874     }
875
876     return 0;
877 }
878
879 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
880 {
881     int level, pred;
882
883     if(s->msmpeg4_version<=2){
884         if (n < 4) {
885             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
886         } else {
887             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
888         }
889         if (level < 0)
890             return -1;
891         level-=256;
892     }else{  //FIXME optimize use unified tables & index
893         if (n < 4) {
894             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
895         } else {
896             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
897         }
898         if (level < 0){
899             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
900             return -1;
901         }
902
903         if (level == DC_MAX) {
904             level = get_bits(&s->gb, 8);
905             if (get_bits1(&s->gb))
906                 level = -level;
907         } else if (level != 0) {
908             if (get_bits1(&s->gb))
909                 level = -level;
910         }
911     }
912
913     if(s->msmpeg4_version==1){
914         int32_t *dc_val;
915         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
916         level += pred;
917
918         /* update predictor */
919         *dc_val= level;
920     }else{
921         int16_t *dc_val;
922         pred   = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
923         level += pred;
924
925         /* update predictor */
926         if (n < 4) {
927             *dc_val = level * s->y_dc_scale;
928         } else {
929             *dc_val = level * s->c_dc_scale;
930         }
931     }
932
933     return level;
934 }
935
936 //#define ERROR_DETAILS
937 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
938                               int n, int coded, const uint8_t *scan_table)
939 {
940     int level, i, last, run, run_diff;
941     int av_uninit(dc_pred_dir);
942     RLTable *rl;
943     RL_VLC_ELEM *rl_vlc;
944     int qmul, qadd;
945
946     if (s->mb_intra) {
947         qmul=1;
948         qadd=0;
949
950         /* DC coef */
951         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
952
953         if (level < 0){
954             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
955             if(s->inter_intra_pred) level=0;
956             else                    return -1;
957         }
958         if (n < 4) {
959             rl = &ff_rl_table[s->rl_table_index];
960             if(level > 256*s->y_dc_scale){
961                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
962                 if(!s->inter_intra_pred) return -1;
963             }
964         } else {
965             rl = &ff_rl_table[3 + s->rl_chroma_table_index];
966             if(level > 256*s->c_dc_scale){
967                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
968                 if(!s->inter_intra_pred) return -1;
969             }
970         }
971         block[0] = level;
972
973         run_diff = s->msmpeg4_version >= 4;
974         i = 0;
975         if (!coded) {
976             goto not_coded;
977         }
978         if (s->ac_pred) {
979             if (dc_pred_dir == 0)
980                 scan_table = s->intra_v_scantable.permutated; /* left */
981             else
982                 scan_table = s->intra_h_scantable.permutated; /* top */
983         } else {
984             scan_table = s->intra_scantable.permutated;
985         }
986         rl_vlc= rl->rl_vlc[0];
987     } else {
988         qmul = s->qscale << 1;
989         qadd = (s->qscale - 1) | 1;
990         i = -1;
991         rl = &ff_rl_table[3 + s->rl_table_index];
992
993         if(s->msmpeg4_version==2)
994             run_diff = 0;
995         else
996             run_diff = 1;
997
998         if (!coded) {
999             s->block_last_index[n] = i;
1000             return 0;
1001         }
1002         if(!scan_table)
1003             scan_table = s->inter_scantable.permutated;
1004         rl_vlc= rl->rl_vlc[s->qscale];
1005     }
1006   {
1007     OPEN_READER(re, &s->gb);
1008     for(;;) {
1009         UPDATE_CACHE(re, &s->gb);
1010         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1011         if (level==0) {
1012             int cache;
1013             cache= GET_CACHE(re, &s->gb);
1014             /* escape */
1015             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1016                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1017                     /* third escape */
1018                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1019                     UPDATE_CACHE(re, &s->gb);
1020                     if(s->msmpeg4_version<=3){
1021                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1022                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1023                         level= SHOW_SBITS(re, &s->gb, 8);
1024                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1025                     }else{
1026                         int sign;
1027                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1028                         if(!s->esc3_level_length){
1029                             int ll;
1030                             av_dlog(s->avctx, "ESC-3 %X at %d %d\n",
1031                                     show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1032                             if(s->qscale<8){
1033                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1034                                 if(ll==0){
1035                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1036                                 }
1037                             }else{
1038                                 ll=2;
1039                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1040                                     ll++;
1041                                     SKIP_BITS(re, &s->gb, 1);
1042                                 }
1043                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1044                             }
1045
1046                             s->esc3_level_length= ll;
1047                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1048                             UPDATE_CACHE(re, &s->gb);
1049                         }
1050                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1051                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1052
1053                         sign=  SHOW_UBITS(re, &s->gb, 1);
1054                         SKIP_BITS(re, &s->gb, 1);
1055
1056                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1057                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1058                         if(sign) level= -level;
1059                     }
1060
1061 #if 0 // waste of time / this will detect very few errors
1062                     {
1063                         const int abs_level= FFABS(level);
1064                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1065                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1066                             if(abs_level <= rl->max_level[last][run]){
1067                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1068                                 return DECODING_AC_LOST;
1069                             }
1070                             if(abs_level <= rl->max_level[last][run]*2){
1071                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1072                                 return DECODING_AC_LOST;
1073                             }
1074                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1075                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1076                                 return DECODING_AC_LOST;
1077                             }
1078                         }
1079                     }
1080 #endif
1081                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1082                     if (level>0) level= level * qmul + qadd;
1083                     else         level= level * qmul - qadd;
1084 #if 0 // waste of time too :(
1085                     if(level>2048 || level<-2048){
1086                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1087                         return DECODING_AC_LOST;
1088                     }
1089 #endif
1090                     i+= run + 1;
1091                     if(last) i+=192;
1092 #ifdef ERROR_DETAILS
1093                 if(run==66)
1094                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1095                 else if((i>62 && i<192) || i>192+63)
1096                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1097 #endif
1098                 } else {
1099                     /* second escape */
1100                     SKIP_BITS(re, &s->gb, 2);
1101                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1102                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1103                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1104                     LAST_SKIP_BITS(re, &s->gb, 1);
1105 #ifdef ERROR_DETAILS
1106                 if(run==66)
1107                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1108                 else if((i>62 && i<192) || i>192+63)
1109                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1110 #endif
1111                 }
1112             } else {
1113                 /* first escape */
1114                 SKIP_BITS(re, &s->gb, 1);
1115                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1116                 i+= run;
1117                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1118                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1119                 LAST_SKIP_BITS(re, &s->gb, 1);
1120 #ifdef ERROR_DETAILS
1121                 if(run==66)
1122                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1123                 else if((i>62 && i<192) || i>192+63)
1124                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1125 #endif
1126             }
1127         } else {
1128             i+= run;
1129             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1130             LAST_SKIP_BITS(re, &s->gb, 1);
1131 #ifdef ERROR_DETAILS
1132                 if(run==66)
1133                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1134                 else if((i>62 && i<192) || i>192+63)
1135                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1136 #endif
1137         }
1138         if (i > 62){
1139             i-= 192;
1140             if(i&(~63)){
1141                 const int left= get_bits_left(&s->gb);
1142                 if(((i+192 == 64 && level/qmul==-1) || !(s->err_recognition&(AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && left>=0){
1143                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1144                     break;
1145                 }else{
1146                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1147                     return -1;
1148                 }
1149             }
1150
1151             block[scan_table[i]] = level;
1152             break;
1153         }
1154
1155         block[scan_table[i]] = level;
1156     }
1157     CLOSE_READER(re, &s->gb);
1158   }
1159  not_coded:
1160     if (s->mb_intra) {
1161         ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1162         if (s->ac_pred) {
1163             i = 63; /* XXX: not optimal */
1164         }
1165     }
1166     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1167     s->block_last_index[n] = i;
1168
1169     return 0;
1170 }
1171
1172 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1173                                  int *mx_ptr, int *my_ptr)
1174 {
1175     MVTable *mv;
1176     int code, mx, my;
1177
1178     mv = &ff_mv_tables[s->mv_table_index];
1179
1180     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1181     if (code < 0){
1182         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1183         return -1;
1184     }
1185     if (code == mv->n) {
1186         mx = get_bits(&s->gb, 6);
1187         my = get_bits(&s->gb, 6);
1188     } else {
1189         mx = mv->table_mvx[code];
1190         my = mv->table_mvy[code];
1191     }
1192
1193     mx += *mx_ptr - 32;
1194     my += *my_ptr - 32;
1195     /* WARNING : they do not do exactly modulo encoding */
1196     if (mx <= -64)
1197         mx += 64;
1198     else if (mx >= 64)
1199         mx -= 64;
1200
1201     if (my <= -64)
1202         my += 64;
1203     else if (my >= 64)
1204         my -= 64;
1205     *mx_ptr = mx;
1206     *my_ptr = my;
1207     return 0;
1208 }
1209
1210 AVCodec ff_msmpeg4v1_decoder = {
1211     .name           = "msmpeg4v1",
1212     .type           = AVMEDIA_TYPE_VIDEO,
1213     .id             = AV_CODEC_ID_MSMPEG4V1,
1214     .priv_data_size = sizeof(MpegEncContext),
1215     .init           = ff_msmpeg4_decode_init,
1216     .close          = ff_h263_decode_end,
1217     .decode         = ff_h263_decode_frame,
1218     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1219     .max_lowres     = 3,
1220     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1221     .pix_fmts       = ff_pixfmt_list_420,
1222 };
1223
1224 AVCodec ff_msmpeg4v2_decoder = {
1225     .name           = "msmpeg4v2",
1226     .type           = AVMEDIA_TYPE_VIDEO,
1227     .id             = AV_CODEC_ID_MSMPEG4V2,
1228     .priv_data_size = sizeof(MpegEncContext),
1229     .init           = ff_msmpeg4_decode_init,
1230     .close          = ff_h263_decode_end,
1231     .decode         = ff_h263_decode_frame,
1232     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1233     .max_lowres     = 3,
1234     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1235     .pix_fmts       = ff_pixfmt_list_420,
1236 };
1237
1238 AVCodec ff_msmpeg4v3_decoder = {
1239     .name           = "msmpeg4",
1240     .type           = AVMEDIA_TYPE_VIDEO,
1241     .id             = AV_CODEC_ID_MSMPEG4V3,
1242     .priv_data_size = sizeof(MpegEncContext),
1243     .init           = ff_msmpeg4_decode_init,
1244     .close          = ff_h263_decode_end,
1245     .decode         = ff_h263_decode_frame,
1246     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1247     .max_lowres     = 3,
1248     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1249     .pix_fmts       = ff_pixfmt_list_420,
1250 };
1251
1252 AVCodec ff_wmv1_decoder = {
1253     .name           = "wmv1",
1254     .type           = AVMEDIA_TYPE_VIDEO,
1255     .id             = AV_CODEC_ID_WMV1,
1256     .priv_data_size = sizeof(MpegEncContext),
1257     .init           = ff_msmpeg4_decode_init,
1258     .close          = ff_h263_decode_end,
1259     .decode         = ff_h263_decode_frame,
1260     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1261     .max_lowres     = 3,
1262     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1263     .pix_fmts       = ff_pixfmt_list_420,
1264 };