2 * MSMPEG4 backend for encoder and decoder
3 * Copyright (c) 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * MSMPEG4 backend for encoder and decoder
32 #include "mpegvideo.h"
34 #include "libavutil/x86/asm.h"
36 #include "mpeg4video.h"
37 #include "msmpeg4data.h"
39 #include "libavutil/imgutils.h"
42 * You can also call this codec : MPEG4 with a twist !
45 * - (encoding) select best mv table (two choices)
46 * - (encoding) select best vlc/dc table
51 #define V2_INTRA_CBPC_VLC_BITS 3
52 #define V2_MB_TYPE_VLC_BITS 7
54 #define V2_MV_VLC_BITS 9
55 #define TEX_VLC_BITS 9
57 #define DEFAULT_INTER_INDEX 3
59 /* This table is practically identical to the one from h263
60 * except that it is inverted. */
61 static av_cold void init_h263_dc_for_msmpeg4(void)
63 int level, uni_code, uni_len;
65 if(ff_v2_dc_chroma_table[255 + 256][1])
68 for(level=-256; level<256; level++){
70 /* find number of bits */
79 l= (-level) ^ ((1 << size) - 1);
84 uni_code= ff_mpeg4_DCtab_lum[size][0];
85 uni_len = ff_mpeg4_DCtab_lum[size][1];
86 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
89 uni_code<<=size; uni_code|=l;
92 uni_code<<=1; uni_code|=1;
96 ff_v2_dc_lum_table[level + 256][0] = uni_code;
97 ff_v2_dc_lum_table[level + 256][1] = uni_len;
99 /* chrominance h263 */
100 uni_code= ff_mpeg4_DCtab_chrom[size][0];
101 uni_len = ff_mpeg4_DCtab_chrom[size][1];
102 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
105 uni_code<<=size; uni_code|=l;
108 uni_code<<=1; uni_code|=1;
112 ff_v2_dc_chroma_table[level + 256][0] = uni_code;
113 ff_v2_dc_chroma_table[level + 256][1] = uni_len;
118 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
120 switch(s->msmpeg4_version){
124 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
127 if(s->workaround_bugs){
128 s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
129 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
131 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
132 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
137 s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
138 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
140 #if CONFIG_VC1_DECODER
142 s->y_dc_scale_table= ff_wmv3_dc_scale_table;
143 s->c_dc_scale_table= ff_wmv3_dc_scale_table;
150 if(s->msmpeg4_version>=4){
151 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_wmv1_scantable[1]);
152 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
153 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
154 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_wmv1_scantable[0]);
156 //Note the default tables are set in common_init in mpegvideo.c
158 init_h263_dc_for_msmpeg4();
161 /* predict coded block */
162 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
164 int xy, wrap, pred, a, b, c;
166 xy = s->block_index[n];
172 a = s->coded_block[xy - 1 ];
173 b = s->coded_block[xy - 1 - wrap];
174 c = s->coded_block[xy - wrap];
183 *coded_block_ptr = &s->coded_block[xy];
188 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
189 int32_t **dc_val_ptr)
199 *dc_val_ptr= &s->last_dc[i];
200 return s->last_dc[i];
203 static int get_dc(uint8_t *src, int stride, int scale)
210 sum+=src[x + y*stride];
213 return FASTDIV((sum + (scale>>1)), scale);
216 /* dir = 0: left, dir = 1: top prediction */
217 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
218 int16_t **dc_val_ptr, int *dir_ptr)
220 int a, b, c, wrap, pred, scale;
223 /* find prediction */
225 scale = s->y_dc_scale;
227 scale = s->c_dc_scale;
230 wrap = s->block_wrap[n];
231 dc_val= s->dc_val[0] + s->block_index[n];
237 b = dc_val[ - 1 - wrap];
240 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
244 /* XXX: the following solution consumes divisions, but it does not
245 necessitate to modify mpegvideo.c. The problem comes from the
246 fact they decided to store the quantized DC (which would lead
247 to problems if Q could vary !) */
248 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
250 "movl %3, %%eax \n\t"
251 "shrl $1, %%eax \n\t"
252 "addl %%eax, %2 \n\t"
253 "addl %%eax, %1 \n\t"
254 "addl %0, %%eax \n\t"
256 "movl %%edx, %0 \n\t"
257 "movl %1, %%eax \n\t"
259 "movl %%edx, %1 \n\t"
260 "movl %2, %%eax \n\t"
262 "movl %%edx, %2 \n\t"
263 : "+b" (a), "+c" (b), "+D" (c)
264 : "g" (scale), "S" (ff_inverse[scale])
268 /* #elif ARCH_ALPHA */
269 /* Divisions are extremely costly on Alpha; optimize the most
270 common case. But they are costly everywhere...
273 a = (a + (8 >> 1)) / 8;
274 b = (b + (8 >> 1)) / 8;
275 c = (c + (8 >> 1)) / 8;
277 a = FASTDIV((a + (scale >> 1)), scale);
278 b = FASTDIV((b + (scale >> 1)), scale);
279 c = FASTDIV((c + (scale >> 1)), scale);
282 /* XXX: WARNING: they did not choose the same test as MPEG4. This
283 is very important ! */
284 if(s->msmpeg4_version>3){
285 if(s->inter_intra_pred){
296 if (abs(a - b) < abs(b - c)) {
306 dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
309 dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
311 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
312 else a= get_dc(dest-8, wrap, scale*8);
313 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
314 else c= get_dc(dest-8*wrap, wrap, scale*8);
316 if (s->h263_aic_dir==0) {
319 }else if (s->h263_aic_dir==1) {
327 }else if (s->h263_aic_dir==2) {
341 if (abs(a - b) < abs(b - c)) {
350 if (abs(a - b) <= abs(b - c)) {
359 /* update predictor */
360 *dc_val_ptr = &dc_val[0];
364 /****************************************/
367 VLC ff_mb_non_intra_vlc[4];
368 static VLC v2_dc_lum_vlc;
369 static VLC v2_dc_chroma_vlc;
370 static VLC v2_intra_cbpc_vlc;
371 static VLC v2_mb_type_vlc;
372 static VLC v2_mv_vlc;
373 VLC ff_inter_intra_vlc;
375 /* This is identical to h263 except that its range is multiplied by 2. */
376 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
378 int code, val, sign, shift;
380 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
381 av_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
387 sign = get_bits1(&s->gb);
391 val = (val - 1) << shift;
392 val |= get_bits(&s->gb, shift);
407 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
410 uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
412 if (s->pict_type == AV_PICTURE_TYPE_P) {
413 if (s->use_skip_mb_code) {
414 if (get_bits1(&s->gb)) {
418 s->block_last_index[i] = -1;
419 s->mv_dir = MV_DIR_FORWARD;
420 s->mv_type = MV_TYPE_16X16;
424 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
429 if(s->msmpeg4_version==2)
430 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
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);
438 s->mb_intra = code >>2;
443 if(s->msmpeg4_version==2)
444 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
446 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
448 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
456 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
458 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
463 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
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);
469 s->mv_dir = MV_DIR_FORWARD;
470 s->mv_type = MV_TYPE_16X16;
473 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
475 if(s->msmpeg4_version==2){
476 s->ac_pred = get_bits1(&s->gb);
477 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
480 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
481 if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
483 *mb_type_ptr = MB_TYPE_INTRA;
486 s->dsp.clear_blocks(s->block[0]);
487 for (i = 0; i < 6; i++) {
488 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
490 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
497 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
501 uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
503 if (s->pict_type == AV_PICTURE_TYPE_P) {
504 if (s->use_skip_mb_code) {
505 if (get_bits1(&s->gb)) {
509 s->block_last_index[i] = -1;
510 s->mv_dir = MV_DIR_FORWARD;
511 s->mv_type = MV_TYPE_16X16;
515 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
521 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
524 //s->mb_intra = (code & 0x40) ? 0 : 1;
525 s->mb_intra = (~code & 0x40) >> 6;
530 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
533 /* predict coded block pattern */
536 int val = ((code >> (5 - i)) & 1);
538 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
542 cbp |= val << (5 - i);
548 if(s->per_mb_rl_table && cbp){
549 s->rl_table_index = decode012(&s->gb);
550 s->rl_chroma_table_index = s->rl_table_index;
552 ff_h263_pred_motion(s, 0, 0, &mx, &my);
553 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
555 s->mv_dir = MV_DIR_FORWARD;
556 s->mv_type = MV_TYPE_16X16;
559 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
561 av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
562 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
563 show_bits(&s->gb, 24));
564 s->ac_pred = get_bits1(&s->gb);
565 *mb_type_ptr = MB_TYPE_INTRA;
566 if(s->inter_intra_pred){
567 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
568 av_dlog(s, "%d%d %d %d/",
569 s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
571 if(s->per_mb_rl_table && cbp){
572 s->rl_table_index = decode012(&s->gb);
573 s->rl_chroma_table_index = s->rl_table_index;
577 s->dsp.clear_blocks(s->block[0]);
578 for (i = 0; i < 6; i++) {
579 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
581 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
589 /* init all vlc decoding tables */
590 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
592 MpegEncContext *s = avctx->priv_data;
593 static volatile int done = 0;
597 if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
600 if (ff_h263_decode_init(avctx) < 0)
603 ff_msmpeg4_common_init(s);
606 for(i=0;i<NB_RL_TABLES;i++) {
607 ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
609 INIT_VLC_RL(ff_rl_table[0], 642);
610 INIT_VLC_RL(ff_rl_table[1], 1104);
611 INIT_VLC_RL(ff_rl_table[2], 554);
612 INIT_VLC_RL(ff_rl_table[3], 940);
613 INIT_VLC_RL(ff_rl_table[4], 962);
614 INIT_VLC_RL(ff_rl_table[5], 554);
616 mv = &ff_mv_tables[0];
617 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
618 mv->table_mv_bits, 1, 1,
619 mv->table_mv_code, 2, 2, 3714);
620 mv = &ff_mv_tables[1];
621 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
622 mv->table_mv_bits, 1, 1,
623 mv->table_mv_code, 2, 2, 2694);
625 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
626 &ff_table0_dc_lum[0][1], 8, 4,
627 &ff_table0_dc_lum[0][0], 8, 4, 1158);
628 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
629 &ff_table0_dc_chroma[0][1], 8, 4,
630 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
631 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
632 &ff_table1_dc_lum[0][1], 8, 4,
633 &ff_table1_dc_lum[0][0], 8, 4, 1476);
634 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
635 &ff_table1_dc_chroma[0][1], 8, 4,
636 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
638 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
639 &ff_v2_dc_lum_table[0][1], 8, 4,
640 &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
641 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
642 &ff_v2_dc_chroma_table[0][1], 8, 4,
643 &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
645 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
646 &ff_v2_intra_cbpc[0][1], 2, 1,
647 &ff_v2_intra_cbpc[0][0], 2, 1, 8);
648 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
649 &ff_v2_mb_type[0][1], 2, 1,
650 &ff_v2_mb_type[0][0], 2, 1, 128);
651 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
652 &ff_mvtab[0][1], 2, 1,
653 &ff_mvtab[0][0], 2, 1, 538);
655 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
656 &ff_wmv2_inter_table[0][0][1], 8, 4,
657 &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
658 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
659 &ff_wmv2_inter_table[1][0][1], 8, 4,
660 &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
661 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
662 &ff_wmv2_inter_table[2][0][1], 8, 4,
663 &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
664 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
665 &ff_wmv2_inter_table[3][0][1], 8, 4,
666 &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
668 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
669 &ff_msmp4_mb_i_table[0][1], 4, 2,
670 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
672 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
673 &ff_table_inter_intra[0][1], 2, 1,
674 &ff_table_inter_intra[0][0], 2, 1, 8);
678 switch(s->msmpeg4_version){
681 s->decode_mb= msmpeg4v12_decode_mb;
685 s->decode_mb= msmpeg4v34_decode_mb;
688 if (CONFIG_WMV2_DECODER)
689 s->decode_mb= ff_wmv2_decode_mb;
691 //FIXME + TODO VC1 decode mb
695 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
700 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
704 if(s->msmpeg4_version==1){
705 int start_code = get_bits_long(&s->gb, 32);
706 if(start_code!=0x00000100){
707 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
711 skip_bits(&s->gb, 5); // frame number */
714 s->pict_type = get_bits(&s->gb, 2) + 1;
715 if (s->pict_type != AV_PICTURE_TYPE_I &&
716 s->pict_type != AV_PICTURE_TYPE_P){
717 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
723 if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
724 if(!had_i) return -1;
727 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
729 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
733 if (s->pict_type == AV_PICTURE_TYPE_I) {
734 code = get_bits(&s->gb, 5);
735 if(s->msmpeg4_version==1){
736 if(code==0 || code>s->mb_height){
737 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
741 s->slice_height = code;
743 /* 0x17: one slice, 0x18: two slices, ... */
745 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
749 s->slice_height = s->mb_height / (code - 0x16);
752 switch(s->msmpeg4_version){
755 s->rl_chroma_table_index = 2;
756 s->rl_table_index = 2;
758 s->dc_table_index = 0; //not used
761 s->rl_chroma_table_index = decode012(&s->gb);
762 s->rl_table_index = decode012(&s->gb);
764 s->dc_table_index = get_bits1(&s->gb);
767 ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
769 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
770 else s->per_mb_rl_table= 0;
772 if(!s->per_mb_rl_table){
773 s->rl_chroma_table_index = decode012(&s->gb);
774 s->rl_table_index = decode012(&s->gb);
777 s->dc_table_index = get_bits1(&s->gb);
778 s->inter_intra_pred= 0;
782 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
783 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
785 s->rl_chroma_table_index,
791 switch(s->msmpeg4_version){
794 if(s->msmpeg4_version==1)
795 s->use_skip_mb_code = 1;
797 s->use_skip_mb_code = get_bits1(&s->gb);
798 s->rl_table_index = 2;
799 s->rl_chroma_table_index = s->rl_table_index;
800 s->dc_table_index = 0; //not used
801 s->mv_table_index = 0;
804 s->use_skip_mb_code = get_bits1(&s->gb);
805 s->rl_table_index = decode012(&s->gb);
806 s->rl_chroma_table_index = s->rl_table_index;
808 s->dc_table_index = get_bits1(&s->gb);
810 s->mv_table_index = get_bits1(&s->gb);
813 s->use_skip_mb_code = get_bits1(&s->gb);
815 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
816 else s->per_mb_rl_table= 0;
818 if(!s->per_mb_rl_table){
819 s->rl_table_index = decode012(&s->gb);
820 s->rl_chroma_table_index = s->rl_table_index;
823 s->dc_table_index = get_bits1(&s->gb);
825 s->mv_table_index = get_bits1(&s->gb);
826 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
830 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
831 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
834 s->rl_chroma_table_index,
840 if(s->flipflop_rounding){
846 av_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
847 s->inter_intra_pred, s->width, s->height);
849 s->esc3_level_length= 0;
850 s->esc3_run_length= 0;
855 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
857 int left= buf_size*8 - get_bits_count(&s->gb);
858 int length= s->msmpeg4_version>=3 ? 17 : 16;
859 /* the alt_bitstream reader could read over the end so we need to check it */
860 if(left>=length && left<length+8)
862 skip_bits(&s->gb, 5); /* fps */
863 s->bit_rate= get_bits(&s->gb, 11)*1024;
864 if(s->msmpeg4_version>=3)
865 s->flipflop_rounding= get_bits1(&s->gb);
867 s->flipflop_rounding= 0;
869 else if(left<length+8)
871 s->flipflop_rounding= 0;
872 if(s->msmpeg4_version != 2)
873 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
877 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
883 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
887 if(s->msmpeg4_version<=2){
889 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
891 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
896 }else{ //FIXME optimize use unified tables & index
898 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
900 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
903 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
907 if (level == DC_MAX) {
908 level = get_bits(&s->gb, 8);
909 if (get_bits1(&s->gb))
911 } else if (level != 0) {
912 if (get_bits1(&s->gb))
917 if(s->msmpeg4_version==1){
919 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
922 /* update predictor */
926 pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
929 /* update predictor */
931 *dc_val = level * s->y_dc_scale;
933 *dc_val = level * s->c_dc_scale;
940 //#define ERROR_DETAILS
941 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
942 int n, int coded, const uint8_t *scan_table)
944 int level, i, last, run, run_diff;
945 int av_uninit(dc_pred_dir);
955 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
958 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
959 if(s->inter_intra_pred) level=0;
963 rl = &ff_rl_table[s->rl_table_index];
964 if(level > 256*s->y_dc_scale){
965 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
966 if(!s->inter_intra_pred) return -1;
969 rl = &ff_rl_table[3 + s->rl_chroma_table_index];
970 if(level > 256*s->c_dc_scale){
971 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
972 if(!s->inter_intra_pred) return -1;
977 run_diff = s->msmpeg4_version >= 4;
983 if (dc_pred_dir == 0)
984 scan_table = s->intra_v_scantable.permutated; /* left */
986 scan_table = s->intra_h_scantable.permutated; /* top */
988 scan_table = s->intra_scantable.permutated;
990 rl_vlc= rl->rl_vlc[0];
992 qmul = s->qscale << 1;
993 qadd = (s->qscale - 1) | 1;
995 rl = &ff_rl_table[3 + s->rl_table_index];
997 if(s->msmpeg4_version==2)
1003 s->block_last_index[n] = i;
1007 scan_table = s->inter_scantable.permutated;
1008 rl_vlc= rl->rl_vlc[s->qscale];
1011 OPEN_READER(re, &s->gb);
1013 UPDATE_CACHE(re, &s->gb);
1014 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1017 cache= GET_CACHE(re, &s->gb);
1019 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1020 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1022 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1023 UPDATE_CACHE(re, &s->gb);
1024 if(s->msmpeg4_version<=3){
1025 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1026 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1027 level= SHOW_SBITS(re, &s->gb, 8);
1028 SKIP_COUNTER(re, &s->gb, 1+6+8);
1031 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1032 if(!s->esc3_level_length){
1034 av_dlog(s->avctx, "ESC-3 %X at %d %d\n",
1035 show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1037 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1039 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1043 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1045 SKIP_BITS(re, &s->gb, 1);
1047 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1050 s->esc3_level_length= ll;
1051 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1052 UPDATE_CACHE(re, &s->gb);
1054 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1055 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1057 sign= SHOW_UBITS(re, &s->gb, 1);
1058 SKIP_BITS(re, &s->gb, 1);
1060 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1061 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1062 if(sign) level= -level;
1065 #if 0 // waste of time / this will detect very few errors
1067 const int abs_level= FFABS(level);
1068 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1069 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1070 if(abs_level <= rl->max_level[last][run]){
1071 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1072 return DECODING_AC_LOST;
1074 if(abs_level <= rl->max_level[last][run]*2){
1075 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1076 return DECODING_AC_LOST;
1078 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1079 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1080 return DECODING_AC_LOST;
1085 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1086 if (level>0) level= level * qmul + qadd;
1087 else level= level * qmul - qadd;
1088 #if 0 // waste of time too :(
1089 if(level>2048 || level<-2048){
1090 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1091 return DECODING_AC_LOST;
1096 #ifdef ERROR_DETAILS
1098 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1099 else if((i>62 && i<192) || i>192+63)
1100 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1104 SKIP_BITS(re, &s->gb, 2);
1105 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1106 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1107 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1108 LAST_SKIP_BITS(re, &s->gb, 1);
1109 #ifdef ERROR_DETAILS
1111 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1112 else if((i>62 && i<192) || i>192+63)
1113 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1118 SKIP_BITS(re, &s->gb, 1);
1119 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1121 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1122 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1123 LAST_SKIP_BITS(re, &s->gb, 1);
1124 #ifdef ERROR_DETAILS
1126 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1127 else if((i>62 && i<192) || i>192+63)
1128 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1133 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1134 LAST_SKIP_BITS(re, &s->gb, 1);
1135 #ifdef ERROR_DETAILS
1137 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1138 else if((i>62 && i<192) || i>192+63)
1139 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1145 const int left= get_bits_left(&s->gb);
1146 if(((i+192 == 64 && level/qmul==-1) || !(s->err_recognition&(AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && left>=0){
1147 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1150 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1155 block[scan_table[i]] = level;
1159 block[scan_table[i]] = level;
1161 CLOSE_READER(re, &s->gb);
1165 ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1167 i = 63; /* XXX: not optimal */
1170 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1171 s->block_last_index[n] = i;
1176 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1177 int *mx_ptr, int *my_ptr)
1182 mv = &ff_mv_tables[s->mv_table_index];
1184 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1186 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1189 if (code == mv->n) {
1190 mx = get_bits(&s->gb, 6);
1191 my = get_bits(&s->gb, 6);
1193 mx = mv->table_mvx[code];
1194 my = mv->table_mvy[code];
1199 /* WARNING : they do not do exactly modulo encoding */
1214 AVCodec ff_msmpeg4v1_decoder = {
1215 .name = "msmpeg4v1",
1216 .type = AVMEDIA_TYPE_VIDEO,
1217 .id = AV_CODEC_ID_MSMPEG4V1,
1218 .priv_data_size = sizeof(MpegEncContext),
1219 .init = ff_msmpeg4_decode_init,
1220 .close = ff_h263_decode_end,
1221 .decode = ff_h263_decode_frame,
1222 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1224 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1225 .pix_fmts = ff_pixfmt_list_420,
1228 AVCodec ff_msmpeg4v2_decoder = {
1229 .name = "msmpeg4v2",
1230 .type = AVMEDIA_TYPE_VIDEO,
1231 .id = AV_CODEC_ID_MSMPEG4V2,
1232 .priv_data_size = sizeof(MpegEncContext),
1233 .init = ff_msmpeg4_decode_init,
1234 .close = ff_h263_decode_end,
1235 .decode = ff_h263_decode_frame,
1236 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1238 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1239 .pix_fmts = ff_pixfmt_list_420,
1242 AVCodec ff_msmpeg4v3_decoder = {
1244 .type = AVMEDIA_TYPE_VIDEO,
1245 .id = AV_CODEC_ID_MSMPEG4V3,
1246 .priv_data_size = sizeof(MpegEncContext),
1247 .init = ff_msmpeg4_decode_init,
1248 .close = ff_h263_decode_end,
1249 .decode = ff_h263_decode_frame,
1250 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1252 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1253 .pix_fmts = ff_pixfmt_list_420,
1256 AVCodec ff_wmv1_decoder = {
1258 .type = AVMEDIA_TYPE_VIDEO,
1259 .id = AV_CODEC_ID_WMV1,
1260 .priv_data_size = sizeof(MpegEncContext),
1261 .init = ff_msmpeg4_decode_init,
1262 .close = ff_h263_decode_end,
1263 .decode = ff_h263_decode_frame,
1264 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1266 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1267 .pix_fmts = ff_pixfmt_list_420,