lavc decoders: work with refcounted frames.
[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     av_dlog(s, "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, int16_t 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, int16_t block[6][64])
496 {
497     int cbp, code, i;
498     uint8_t *coded_val;
499     uint32_t * const mb_type_ptr = &s->current_picture.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         av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
560                 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
561                 show_bits(&s->gb, 24));
562         s->ac_pred = get_bits1(&s->gb);
563         *mb_type_ptr = MB_TYPE_INTRA;
564         if(s->inter_intra_pred){
565             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
566             av_dlog(s, "%d%d %d %d/",
567                     s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
568         }
569         if(s->per_mb_rl_table && cbp){
570             s->rl_table_index = decode012(&s->gb);
571             s->rl_chroma_table_index = s->rl_table_index;
572         }
573     }
574
575     s->dsp.clear_blocks(s->block[0]);
576     for (i = 0; i < 6; i++) {
577         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
578         {
579             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
580             return -1;
581         }
582     }
583
584     return 0;
585 }
586
587 /* init all vlc decoding tables */
588 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
589 {
590     MpegEncContext *s = avctx->priv_data;
591     static int done = 0;
592     int i;
593     MVTable *mv;
594
595     if (ff_h263_decode_init(avctx) < 0)
596         return -1;
597
598     ff_msmpeg4_common_init(s);
599
600     if (!done) {
601         done = 1;
602
603         for(i=0;i<NB_RL_TABLES;i++) {
604             ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
605         }
606         INIT_VLC_RL(ff_rl_table[0], 642);
607         INIT_VLC_RL(ff_rl_table[1], 1104);
608         INIT_VLC_RL(ff_rl_table[2], 554);
609         INIT_VLC_RL(ff_rl_table[3], 940);
610         INIT_VLC_RL(ff_rl_table[4], 962);
611         INIT_VLC_RL(ff_rl_table[5], 554);
612
613         mv = &ff_mv_tables[0];
614         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
615                     mv->table_mv_bits, 1, 1,
616                     mv->table_mv_code, 2, 2, 3714);
617         mv = &ff_mv_tables[1];
618         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
619                     mv->table_mv_bits, 1, 1,
620                     mv->table_mv_code, 2, 2, 2694);
621
622         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
623                  &ff_table0_dc_lum[0][1], 8, 4,
624                  &ff_table0_dc_lum[0][0], 8, 4, 1158);
625         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
626                  &ff_table0_dc_chroma[0][1], 8, 4,
627                  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
628         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
629                  &ff_table1_dc_lum[0][1], 8, 4,
630                  &ff_table1_dc_lum[0][0], 8, 4, 1476);
631         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
632                  &ff_table1_dc_chroma[0][1], 8, 4,
633                  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
634
635         INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
636                  &ff_v2_dc_lum_table[0][1], 8, 4,
637                  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
638         INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
639                  &ff_v2_dc_chroma_table[0][1], 8, 4,
640                  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
641
642         INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
643                  &ff_v2_intra_cbpc[0][1], 2, 1,
644                  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
645         INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
646                  &ff_v2_mb_type[0][1], 2, 1,
647                  &ff_v2_mb_type[0][0], 2, 1, 128);
648         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
649                  &ff_mvtab[0][1], 2, 1,
650                  &ff_mvtab[0][0], 2, 1, 538);
651
652         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
653                      &ff_wmv2_inter_table[0][0][1], 8, 4,
654                      &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
655         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
656                      &ff_wmv2_inter_table[1][0][1], 8, 4,
657                      &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
658         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
659                      &ff_wmv2_inter_table[2][0][1], 8, 4,
660                      &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
661         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
662                      &ff_wmv2_inter_table[3][0][1], 8, 4,
663                      &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
664
665         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
666                  &ff_msmp4_mb_i_table[0][1], 4, 2,
667                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
668
669         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
670                  &ff_table_inter_intra[0][1], 2, 1,
671                  &ff_table_inter_intra[0][0], 2, 1, 8);
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, int16_t * 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)) && 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     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1220     .pix_fmts       = ff_pixfmt_list_420,
1221 };
1222
1223 AVCodec ff_msmpeg4v2_decoder = {
1224     .name           = "msmpeg4v2",
1225     .type           = AVMEDIA_TYPE_VIDEO,
1226     .id             = AV_CODEC_ID_MSMPEG4V2,
1227     .priv_data_size = sizeof(MpegEncContext),
1228     .init           = ff_msmpeg4_decode_init,
1229     .close          = ff_h263_decode_end,
1230     .decode         = ff_h263_decode_frame,
1231     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1232     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1233     .pix_fmts       = ff_pixfmt_list_420,
1234 };
1235
1236 AVCodec ff_msmpeg4v3_decoder = {
1237     .name           = "msmpeg4",
1238     .type           = AVMEDIA_TYPE_VIDEO,
1239     .id             = AV_CODEC_ID_MSMPEG4V3,
1240     .priv_data_size = sizeof(MpegEncContext),
1241     .init           = ff_msmpeg4_decode_init,
1242     .close          = ff_h263_decode_end,
1243     .decode         = ff_h263_decode_frame,
1244     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1245     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1246     .pix_fmts       = ff_pixfmt_list_420,
1247 };
1248
1249 AVCodec ff_wmv1_decoder = {
1250     .name           = "wmv1",
1251     .type           = AVMEDIA_TYPE_VIDEO,
1252     .id             = AV_CODEC_ID_WMV1,
1253     .priv_data_size = sizeof(MpegEncContext),
1254     .init           = ff_msmpeg4_decode_init,
1255     .close          = ff_h263_decode_end,
1256     .decode         = ff_h263_decode_frame,
1257     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1258     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1259     .pix_fmts       = ff_pixfmt_list_420,
1260 };