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