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 Libav.
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.
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.
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
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"
41 * You can also call this codec : MPEG4 with a twist !
44 * - (encoding) select best mv table (two choices)
45 * - (encoding) select best vlc/dc table
50 #define V2_INTRA_CBPC_VLC_BITS 3
51 #define V2_MB_TYPE_VLC_BITS 7
53 #define V2_MV_VLC_BITS 9
54 #define TEX_VLC_BITS 9
56 #define DEFAULT_INTER_INDEX 3
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)
62 int level, uni_code, uni_len;
64 for(level=-256; level<256; level++){
66 /* find number of bits */
75 l= (-level) ^ ((1 << size) - 1);
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
85 uni_code<<=size; uni_code|=l;
88 uni_code<<=1; uni_code|=1;
92 ff_v2_dc_lum_table[level + 256][0] = uni_code;
93 ff_v2_dc_lum_table[level + 256][1] = uni_len;
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
101 uni_code<<=size; uni_code|=l;
104 uni_code<<=1; uni_code|=1;
108 ff_v2_dc_chroma_table[level + 256][0] = uni_code;
109 ff_v2_dc_chroma_table[level + 256][1] = uni_len;
114 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
116 static int initialized=0;
118 switch(s->msmpeg4_version){
122 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
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;
129 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
130 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
135 s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
136 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
138 #if CONFIG_VC1_DECODER
140 s->y_dc_scale_table= ff_wmv3_dc_scale_table;
141 s->c_dc_scale_table= ff_wmv3_dc_scale_table;
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]);
154 //Note the default tables are set in common_init in mpegvideo.c
159 init_h263_dc_for_msmpeg4();
163 /* predict coded block */
164 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
166 int xy, wrap, pred, a, b, c;
168 xy = s->block_index[n];
174 a = s->coded_block[xy - 1 ];
175 b = s->coded_block[xy - 1 - wrap];
176 c = s->coded_block[xy - wrap];
185 *coded_block_ptr = &s->coded_block[xy];
190 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
191 int32_t **dc_val_ptr)
201 *dc_val_ptr= &s->last_dc[i];
202 return s->last_dc[i];
205 static int get_dc(uint8_t *src, int stride, int scale)
212 sum+=src[x + y*stride];
215 return FASTDIV((sum + (scale>>1)), scale);
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)
222 int a, b, c, wrap, pred, scale;
225 /* find prediction */
227 scale = s->y_dc_scale;
229 scale = s->c_dc_scale;
232 wrap = s->block_wrap[n];
233 dc_val= s->dc_val[0] + s->block_index[n];
239 b = dc_val[ - 1 - wrap];
242 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
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
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"
258 "movl %%edx, %0 \n\t"
259 "movl %1, %%eax \n\t"
261 "movl %%edx, %1 \n\t"
262 "movl %2, %%eax \n\t"
264 "movl %%edx, %2 \n\t"
265 : "+b" (a), "+c" (b), "+D" (c)
266 : "g" (scale), "S" (ff_inverse[scale])
270 /* #elif ARCH_ALPHA */
271 /* Divisions are extremely costly on Alpha; optimize the most
272 common case. But they are costly everywhere...
275 a = (a + (8 >> 1)) / 8;
276 b = (b + (8 >> 1)) / 8;
277 c = (c + (8 >> 1)) / 8;
279 a = FASTDIV((a + (scale >> 1)), scale);
280 b = FASTDIV((b + (scale >> 1)), scale);
281 c = FASTDIV((c + (scale >> 1)), scale);
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){
298 if (abs(a - b) < abs(b - c)) {
308 dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
311 dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
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);
318 if (s->h263_aic_dir==0) {
321 }else if (s->h263_aic_dir==1) {
329 }else if (s->h263_aic_dir==2) {
343 if (abs(a - b) < abs(b - c)) {
352 if (abs(a - b) <= abs(b - c)) {
361 /* update predictor */
362 *dc_val_ptr = &dc_val[0];
366 /****************************************/
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;
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)
380 int code, val, sign, shift;
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);
389 sign = get_bits1(&s->gb);
393 val = (val - 1) << shift;
394 val |= get_bits(&s->gb, shift);
409 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
413 if (s->pict_type == AV_PICTURE_TYPE_P) {
414 if (s->use_skip_mb_code) {
415 if (get_bits1(&s->gb)) {
419 s->block_last_index[i] = -1;
420 s->mv_dir = MV_DIR_FORWARD;
421 s->mv_type = MV_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;
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
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;
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)
488 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
495 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
499 uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
501 if (s->pict_type == AV_PICTURE_TYPE_P) {
502 if (s->use_skip_mb_code) {
503 if (get_bits1(&s->gb)) {
507 s->block_last_index[i] = -1;
508 s->mv_dir = MV_DIR_FORWARD;
509 s->mv_type = MV_TYPE_16X16;
513 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
519 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
522 //s->mb_intra = (code & 0x40) ? 0 : 1;
523 s->mb_intra = (~code & 0x40) >> 6;
528 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
531 /* predict coded block pattern */
534 int val = ((code >> (5 - i)) & 1);
536 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
540 cbp |= val << (5 - i);
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;
550 ff_h263_pred_motion(s, 0, 0, &mx, &my);
551 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
553 s->mv_dir = MV_DIR_FORWARD;
554 s->mv_type = MV_TYPE_16X16;
557 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
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);
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;
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)
579 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
587 /* init all vlc decoding tables */
588 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
590 MpegEncContext *s = avctx->priv_data;
595 if (ff_h263_decode_init(avctx) < 0)
598 ff_msmpeg4_common_init(s);
603 for(i=0;i<NB_RL_TABLES;i++) {
604 ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
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);
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);
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);
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);
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);
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);
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);
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);
674 switch(s->msmpeg4_version){
677 s->decode_mb= msmpeg4v12_decode_mb;
681 s->decode_mb= msmpeg4v34_decode_mb;
684 if (CONFIG_WMV2_DECODER)
685 s->decode_mb= ff_wmv2_decode_mb;
687 //FIXME + TODO VC1 decode mb
691 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
696 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
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");
707 skip_bits(&s->gb, 5); // frame number */
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");
719 if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
720 if(!had_i) return -1;
723 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
725 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
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);
737 s->slice_height = code;
739 /* 0x17: one slice, 0x18: two slices, ... */
741 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
745 s->slice_height = s->mb_height / (code - 0x16);
748 switch(s->msmpeg4_version){
751 s->rl_chroma_table_index = 2;
752 s->rl_table_index = 2;
754 s->dc_table_index = 0; //not used
757 s->rl_chroma_table_index = decode012(&s->gb);
758 s->rl_table_index = decode012(&s->gb);
760 s->dc_table_index = get_bits1(&s->gb);
763 ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
765 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
766 else s->per_mb_rl_table= 0;
768 if(!s->per_mb_rl_table){
769 s->rl_chroma_table_index = decode012(&s->gb);
770 s->rl_table_index = decode012(&s->gb);
773 s->dc_table_index = get_bits1(&s->gb);
774 s->inter_intra_pred= 0;
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",
781 s->rl_chroma_table_index,
787 switch(s->msmpeg4_version){
790 if(s->msmpeg4_version==1)
791 s->use_skip_mb_code = 1;
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;
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;
804 s->dc_table_index = get_bits1(&s->gb);
806 s->mv_table_index = get_bits1(&s->gb);
809 s->use_skip_mb_code = get_bits1(&s->gb);
811 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
812 else s->per_mb_rl_table= 0;
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;
819 s->dc_table_index = get_bits1(&s->gb);
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);
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",
830 s->rl_chroma_table_index,
836 if(s->flipflop_rounding){
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);
845 s->esc3_level_length= 0;
846 s->esc3_run_length= 0;
851 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
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)
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);
863 s->flipflop_rounding= 0;
865 else if(left<length+8)
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);
873 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
879 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
883 if(s->msmpeg4_version<=2){
885 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
887 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
892 }else{ //FIXME optimize use unified tables & index
894 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
896 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
899 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
903 if (level == DC_MAX) {
904 level = get_bits(&s->gb, 8);
905 if (get_bits1(&s->gb))
907 } else if (level != 0) {
908 if (get_bits1(&s->gb))
913 if(s->msmpeg4_version==1){
915 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
918 /* update predictor */
922 pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
925 /* update predictor */
927 *dc_val = level * s->y_dc_scale;
929 *dc_val = level * s->c_dc_scale;
936 //#define ERROR_DETAILS
937 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
938 int n, int coded, const uint8_t *scan_table)
940 int level, i, last, run, run_diff;
941 int av_uninit(dc_pred_dir);
951 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
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;
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;
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;
973 run_diff = s->msmpeg4_version >= 4;
979 if (dc_pred_dir == 0)
980 scan_table = s->intra_v_scantable.permutated; /* left */
982 scan_table = s->intra_h_scantable.permutated; /* top */
984 scan_table = s->intra_scantable.permutated;
986 rl_vlc= rl->rl_vlc[0];
988 qmul = s->qscale << 1;
989 qadd = (s->qscale - 1) | 1;
991 rl = &ff_rl_table[3 + s->rl_table_index];
993 if(s->msmpeg4_version==2)
999 s->block_last_index[n] = i;
1003 scan_table = s->inter_scantable.permutated;
1004 rl_vlc= rl->rl_vlc[s->qscale];
1007 OPEN_READER(re, &s->gb);
1009 UPDATE_CACHE(re, &s->gb);
1010 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1013 cache= GET_CACHE(re, &s->gb);
1015 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1016 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
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);
1027 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1028 if(!s->esc3_level_length){
1030 av_dlog(s->avctx, "ESC-3 %X at %d %d\n",
1031 show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1033 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1035 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1039 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1041 SKIP_BITS(re, &s->gb, 1);
1043 if(ll<8) SKIP_BITS(re, &s->gb, 1);
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);
1050 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1051 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1053 sign= SHOW_UBITS(re, &s->gb, 1);
1054 SKIP_BITS(re, &s->gb, 1);
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;
1061 #if 0 // waste of time / this will detect very few errors
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;
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;
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;
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;
1092 #ifdef ERROR_DETAILS
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);
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
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);
1114 SKIP_BITS(re, &s->gb, 1);
1115 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
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
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);
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
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);
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);
1146 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1151 block[scan_table[i]] = level;
1155 block[scan_table[i]] = level;
1157 CLOSE_READER(re, &s->gb);
1161 ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1163 i = 63; /* XXX: not optimal */
1166 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1167 s->block_last_index[n] = i;
1172 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1173 int *mx_ptr, int *my_ptr)
1178 mv = &ff_mv_tables[s->mv_table_index];
1180 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1182 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1185 if (code == mv->n) {
1186 mx = get_bits(&s->gb, 6);
1187 my = get_bits(&s->gb, 6);
1189 mx = mv->table_mvx[code];
1190 my = mv->table_mvy[code];
1195 /* WARNING : they do not do exactly modulo encoding */
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,
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,
1236 AVCodec ff_msmpeg4v3_decoder = {
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,
1249 AVCodec ff_wmv1_decoder = {
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,