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"
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 if(ff_v2_dc_chroma_table[255 + 256][1])
67 for(level=-256; level<256; level++){
69 /* find number of bits */
78 l= (-level) ^ ((1 << size) - 1);
83 uni_code= ff_mpeg4_DCtab_lum[size][0];
84 uni_len = ff_mpeg4_DCtab_lum[size][1];
85 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
88 uni_code<<=size; uni_code|=l;
91 uni_code<<=1; uni_code|=1;
95 ff_v2_dc_lum_table[level + 256][0] = uni_code;
96 ff_v2_dc_lum_table[level + 256][1] = uni_len;
98 /* chrominance h263 */
99 uni_code= ff_mpeg4_DCtab_chrom[size][0];
100 uni_len = ff_mpeg4_DCtab_chrom[size][1];
101 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
104 uni_code<<=size; uni_code|=l;
107 uni_code<<=1; uni_code|=1;
111 ff_v2_dc_chroma_table[level + 256][0] = uni_code;
112 ff_v2_dc_chroma_table[level + 256][1] = uni_len;
117 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
119 switch(s->msmpeg4_version){
123 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
126 if(s->workaround_bugs){
127 s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
128 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
130 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
131 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
136 s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
137 s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
139 #if CONFIG_VC1_DECODER
141 s->y_dc_scale_table= ff_wmv3_dc_scale_table;
142 s->c_dc_scale_table= ff_wmv3_dc_scale_table;
149 if(s->msmpeg4_version>=4){
150 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_wmv1_scantable[1]);
151 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
152 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
153 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_wmv1_scantable[0]);
155 //Note the default tables are set in common_init in mpegvideo.c
157 init_h263_dc_for_msmpeg4();
160 /* predict coded block */
161 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
163 int xy, wrap, pred, a, b, c;
165 xy = s->block_index[n];
171 a = s->coded_block[xy - 1 ];
172 b = s->coded_block[xy - 1 - wrap];
173 c = s->coded_block[xy - wrap];
182 *coded_block_ptr = &s->coded_block[xy];
187 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
188 int32_t **dc_val_ptr)
198 *dc_val_ptr= &s->last_dc[i];
199 return s->last_dc[i];
202 static int get_dc(uint8_t *src, int stride, int scale)
209 sum+=src[x + y*stride];
212 return FASTDIV((sum + (scale>>1)), scale);
215 /* dir = 0: left, dir = 1: top prediction */
216 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
217 int16_t **dc_val_ptr, int *dir_ptr)
219 int a, b, c, wrap, pred, scale;
222 /* find prediction */
224 scale = s->y_dc_scale;
226 scale = s->c_dc_scale;
229 wrap = s->block_wrap[n];
230 dc_val= s->dc_val[0] + s->block_index[n];
236 b = dc_val[ - 1 - wrap];
239 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
243 /* XXX: the following solution consumes divisions, but it does not
244 necessitate to modify mpegvideo.c. The problem comes from the
245 fact they decided to store the quantized DC (which would lead
246 to problems if Q could vary !) */
247 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
249 "movl %3, %%eax \n\t"
250 "shrl $1, %%eax \n\t"
251 "addl %%eax, %2 \n\t"
252 "addl %%eax, %1 \n\t"
253 "addl %0, %%eax \n\t"
255 "movl %%edx, %0 \n\t"
256 "movl %1, %%eax \n\t"
258 "movl %%edx, %1 \n\t"
259 "movl %2, %%eax \n\t"
261 "movl %%edx, %2 \n\t"
262 : "+b" (a), "+c" (b), "+D" (c)
263 : "g" (scale), "S" (ff_inverse[scale])
267 /* #elif ARCH_ALPHA */
268 /* Divisions are extremely costly on Alpha; optimize the most
269 common case. But they are costly everywhere...
272 a = (a + (8 >> 1)) / 8;
273 b = (b + (8 >> 1)) / 8;
274 c = (c + (8 >> 1)) / 8;
276 a = FASTDIV((a + (scale >> 1)), scale);
277 b = FASTDIV((b + (scale >> 1)), scale);
278 c = FASTDIV((c + (scale >> 1)), scale);
281 /* XXX: WARNING: they did not choose the same test as MPEG4. This
282 is very important ! */
283 if(s->msmpeg4_version>3){
284 if(s->inter_intra_pred){
295 if (abs(a - b) < abs(b - c)) {
305 dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
308 dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
310 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
311 else a= get_dc(dest-8, wrap, scale*8);
312 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
313 else c= get_dc(dest-8*wrap, wrap, scale*8);
315 if (s->h263_aic_dir==0) {
318 }else if (s->h263_aic_dir==1) {
326 }else if (s->h263_aic_dir==2) {
340 if (abs(a - b) < abs(b - c)) {
349 if (abs(a - b) <= abs(b - c)) {
358 /* update predictor */
359 *dc_val_ptr = &dc_val[0];
363 /****************************************/
366 VLC ff_mb_non_intra_vlc[4];
367 static VLC v2_dc_lum_vlc;
368 static VLC v2_dc_chroma_vlc;
369 static VLC v2_intra_cbpc_vlc;
370 static VLC v2_mb_type_vlc;
371 static VLC v2_mv_vlc;
372 VLC ff_inter_intra_vlc;
374 /* This is identical to h263 except that its range is multiplied by 2. */
375 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
377 int code, val, sign, shift;
379 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
380 av_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
386 sign = get_bits1(&s->gb);
390 val = (val - 1) << shift;
391 val |= get_bits(&s->gb, shift);
406 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
409 uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
411 if (s->pict_type == AV_PICTURE_TYPE_P) {
412 if (s->use_skip_mb_code) {
413 if (get_bits1(&s->gb)) {
417 s->block_last_index[i] = -1;
418 s->mv_dir = MV_DIR_FORWARD;
419 s->mv_type = MV_TYPE_16X16;
423 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
428 if(s->msmpeg4_version==2)
429 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
431 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
432 if(code<0 || code>7){
433 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
437 s->mb_intra = code >>2;
442 if(s->msmpeg4_version==2)
443 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
445 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
447 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
455 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
457 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
462 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
464 ff_h263_pred_motion(s, 0, 0, &mx, &my);
465 mx= msmpeg4v2_decode_motion(s, mx, 1);
466 my= msmpeg4v2_decode_motion(s, my, 1);
468 s->mv_dir = MV_DIR_FORWARD;
469 s->mv_type = MV_TYPE_16X16;
472 *mb_type_ptr = MB_TYPE_L0 | MB_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;
482 *mb_type_ptr = MB_TYPE_INTRA;
485 s->dsp.clear_blocks(s->block[0]);
486 for (i = 0; i < 6; i++) {
487 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
489 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
496 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
500 uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
502 if (s->pict_type == AV_PICTURE_TYPE_P) {
503 if (s->use_skip_mb_code) {
504 if (get_bits1(&s->gb)) {
508 s->block_last_index[i] = -1;
509 s->mv_dir = MV_DIR_FORWARD;
510 s->mv_type = MV_TYPE_16X16;
514 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
520 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
523 //s->mb_intra = (code & 0x40) ? 0 : 1;
524 s->mb_intra = (~code & 0x40) >> 6;
529 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
532 /* predict coded block pattern */
535 int val = ((code >> (5 - i)) & 1);
537 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
541 cbp |= val << (5 - i);
547 if(s->per_mb_rl_table && cbp){
548 s->rl_table_index = decode012(&s->gb);
549 s->rl_chroma_table_index = s->rl_table_index;
551 ff_h263_pred_motion(s, 0, 0, &mx, &my);
552 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
554 s->mv_dir = MV_DIR_FORWARD;
555 s->mv_type = MV_TYPE_16X16;
558 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
560 av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
561 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
562 show_bits(&s->gb, 24));
563 s->ac_pred = get_bits1(&s->gb);
564 *mb_type_ptr = MB_TYPE_INTRA;
565 if(s->inter_intra_pred){
566 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
567 av_dlog(s, "%d%d %d %d/",
568 s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
570 if(s->per_mb_rl_table && cbp){
571 s->rl_table_index = decode012(&s->gb);
572 s->rl_chroma_table_index = s->rl_table_index;
576 s->dsp.clear_blocks(s->block[0]);
577 for (i = 0; i < 6; i++) {
578 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
580 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
588 /* init all vlc decoding tables */
589 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
591 MpegEncContext *s = avctx->priv_data;
592 static volatile int done = 0;
596 if(avctx->width<=0 || avctx->height<=0) {
597 av_log(avctx, AV_LOG_ERROR, "invalid dimensions\n");
601 if (ff_h263_decode_init(avctx) < 0)
604 ff_msmpeg4_common_init(s);
607 for(i=0;i<NB_RL_TABLES;i++) {
608 ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
610 INIT_VLC_RL(ff_rl_table[0], 642);
611 INIT_VLC_RL(ff_rl_table[1], 1104);
612 INIT_VLC_RL(ff_rl_table[2], 554);
613 INIT_VLC_RL(ff_rl_table[3], 940);
614 INIT_VLC_RL(ff_rl_table[4], 962);
615 INIT_VLC_RL(ff_rl_table[5], 554);
617 mv = &ff_mv_tables[0];
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, 3714);
621 mv = &ff_mv_tables[1];
622 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
623 mv->table_mv_bits, 1, 1,
624 mv->table_mv_code, 2, 2, 2694);
626 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
627 &ff_table0_dc_lum[0][1], 8, 4,
628 &ff_table0_dc_lum[0][0], 8, 4, 1158);
629 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
630 &ff_table0_dc_chroma[0][1], 8, 4,
631 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
632 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
633 &ff_table1_dc_lum[0][1], 8, 4,
634 &ff_table1_dc_lum[0][0], 8, 4, 1476);
635 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
636 &ff_table1_dc_chroma[0][1], 8, 4,
637 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
639 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
640 &ff_v2_dc_lum_table[0][1], 8, 4,
641 &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
642 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
643 &ff_v2_dc_chroma_table[0][1], 8, 4,
644 &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
646 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
647 &ff_v2_intra_cbpc[0][1], 2, 1,
648 &ff_v2_intra_cbpc[0][0], 2, 1, 8);
649 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
650 &ff_v2_mb_type[0][1], 2, 1,
651 &ff_v2_mb_type[0][0], 2, 1, 128);
652 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
653 &ff_mvtab[0][1], 2, 1,
654 &ff_mvtab[0][0], 2, 1, 538);
656 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
657 &ff_wmv2_inter_table[0][0][1], 8, 4,
658 &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
659 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
660 &ff_wmv2_inter_table[1][0][1], 8, 4,
661 &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
662 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
663 &ff_wmv2_inter_table[2][0][1], 8, 4,
664 &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
665 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
666 &ff_wmv2_inter_table[3][0][1], 8, 4,
667 &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
669 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
670 &ff_msmp4_mb_i_table[0][1], 4, 2,
671 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
673 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
674 &ff_table_inter_intra[0][1], 2, 1,
675 &ff_table_inter_intra[0][0], 2, 1, 8);
679 switch(s->msmpeg4_version){
682 s->decode_mb= msmpeg4v12_decode_mb;
686 s->decode_mb= msmpeg4v34_decode_mb;
689 if (CONFIG_WMV2_DECODER)
690 s->decode_mb= ff_wmv2_decode_mb;
692 //FIXME + TODO VC1 decode mb
696 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
701 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
705 if(s->msmpeg4_version==1){
706 int start_code = get_bits_long(&s->gb, 32);
707 if(start_code!=0x00000100){
708 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
712 skip_bits(&s->gb, 5); // frame number */
715 s->pict_type = get_bits(&s->gb, 2) + 1;
716 if (s->pict_type != AV_PICTURE_TYPE_I &&
717 s->pict_type != AV_PICTURE_TYPE_P){
718 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
724 if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
725 if(!had_i) return -1;
728 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
730 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
734 if (s->pict_type == AV_PICTURE_TYPE_I) {
735 code = get_bits(&s->gb, 5);
736 if(s->msmpeg4_version==1){
737 if(code==0 || code>s->mb_height){
738 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
742 s->slice_height = code;
744 /* 0x17: one slice, 0x18: two slices, ... */
746 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
750 s->slice_height = s->mb_height / (code - 0x16);
753 switch(s->msmpeg4_version){
756 s->rl_chroma_table_index = 2;
757 s->rl_table_index = 2;
759 s->dc_table_index = 0; //not used
762 s->rl_chroma_table_index = decode012(&s->gb);
763 s->rl_table_index = decode012(&s->gb);
765 s->dc_table_index = get_bits1(&s->gb);
768 ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
770 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
771 else s->per_mb_rl_table= 0;
773 if(!s->per_mb_rl_table){
774 s->rl_chroma_table_index = decode012(&s->gb);
775 s->rl_table_index = decode012(&s->gb);
778 s->dc_table_index = get_bits1(&s->gb);
779 s->inter_intra_pred= 0;
783 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
784 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
786 s->rl_chroma_table_index,
792 switch(s->msmpeg4_version){
795 if(s->msmpeg4_version==1)
796 s->use_skip_mb_code = 1;
798 s->use_skip_mb_code = get_bits1(&s->gb);
799 s->rl_table_index = 2;
800 s->rl_chroma_table_index = s->rl_table_index;
801 s->dc_table_index = 0; //not used
802 s->mv_table_index = 0;
805 s->use_skip_mb_code = get_bits1(&s->gb);
806 s->rl_table_index = decode012(&s->gb);
807 s->rl_chroma_table_index = s->rl_table_index;
809 s->dc_table_index = get_bits1(&s->gb);
811 s->mv_table_index = get_bits1(&s->gb);
814 s->use_skip_mb_code = get_bits1(&s->gb);
816 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
817 else s->per_mb_rl_table= 0;
819 if(!s->per_mb_rl_table){
820 s->rl_table_index = decode012(&s->gb);
821 s->rl_chroma_table_index = s->rl_table_index;
824 s->dc_table_index = get_bits1(&s->gb);
826 s->mv_table_index = get_bits1(&s->gb);
827 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
831 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
832 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
835 s->rl_chroma_table_index,
841 if(s->flipflop_rounding){
847 av_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
848 s->inter_intra_pred, s->width, s->height);
850 s->esc3_level_length= 0;
851 s->esc3_run_length= 0;
856 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
858 int left= buf_size*8 - get_bits_count(&s->gb);
859 int length= s->msmpeg4_version>=3 ? 17 : 16;
860 /* the alt_bitstream reader could read over the end so we need to check it */
861 if(left>=length && left<length+8)
863 skip_bits(&s->gb, 5); /* fps */
864 s->bit_rate= get_bits(&s->gb, 11)*1024;
865 if(s->msmpeg4_version>=3)
866 s->flipflop_rounding= get_bits1(&s->gb);
868 s->flipflop_rounding= 0;
870 else if(left<length+8)
872 s->flipflop_rounding= 0;
873 if(s->msmpeg4_version != 2)
874 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
878 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
884 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
888 if(s->msmpeg4_version<=2){
890 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
892 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
897 }else{ //FIXME optimize use unified tables & index
899 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
901 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
904 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
908 if (level == DC_MAX) {
909 level = get_bits(&s->gb, 8);
910 if (get_bits1(&s->gb))
912 } else if (level != 0) {
913 if (get_bits1(&s->gb))
918 if(s->msmpeg4_version==1){
920 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
923 /* update predictor */
927 pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
930 /* update predictor */
932 *dc_val = level * s->y_dc_scale;
934 *dc_val = level * s->c_dc_scale;
941 //#define ERROR_DETAILS
942 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
943 int n, int coded, const uint8_t *scan_table)
945 int level, i, last, run, run_diff;
946 int av_uninit(dc_pred_dir);
956 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
959 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
960 if(s->inter_intra_pred) level=0;
964 rl = &ff_rl_table[s->rl_table_index];
965 if(level > 256*s->y_dc_scale){
966 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
967 if(!s->inter_intra_pred) return -1;
970 rl = &ff_rl_table[3 + s->rl_chroma_table_index];
971 if(level > 256*s->c_dc_scale){
972 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
973 if(!s->inter_intra_pred) return -1;
978 run_diff = s->msmpeg4_version >= 4;
984 if (dc_pred_dir == 0)
985 scan_table = s->intra_v_scantable.permutated; /* left */
987 scan_table = s->intra_h_scantable.permutated; /* top */
989 scan_table = s->intra_scantable.permutated;
991 rl_vlc= rl->rl_vlc[0];
993 qmul = s->qscale << 1;
994 qadd = (s->qscale - 1) | 1;
996 rl = &ff_rl_table[3 + s->rl_table_index];
998 if(s->msmpeg4_version==2)
1004 s->block_last_index[n] = i;
1008 scan_table = s->inter_scantable.permutated;
1009 rl_vlc= rl->rl_vlc[s->qscale];
1012 OPEN_READER(re, &s->gb);
1014 UPDATE_CACHE(re, &s->gb);
1015 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1018 cache= GET_CACHE(re, &s->gb);
1020 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1021 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1023 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1024 UPDATE_CACHE(re, &s->gb);
1025 if(s->msmpeg4_version<=3){
1026 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1027 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1028 level= SHOW_SBITS(re, &s->gb, 8);
1029 SKIP_COUNTER(re, &s->gb, 1+6+8);
1032 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1033 if(!s->esc3_level_length){
1035 av_dlog(s->avctx, "ESC-3 %X at %d %d\n",
1036 show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1038 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1040 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1044 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1046 SKIP_BITS(re, &s->gb, 1);
1048 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1051 s->esc3_level_length= ll;
1052 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1053 UPDATE_CACHE(re, &s->gb);
1055 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1056 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1058 sign= SHOW_UBITS(re, &s->gb, 1);
1059 SKIP_BITS(re, &s->gb, 1);
1061 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1062 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1063 if(sign) level= -level;
1066 #if 0 // waste of time / this will detect very few errors
1068 const int abs_level= FFABS(level);
1069 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1070 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1071 if(abs_level <= rl->max_level[last][run]){
1072 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1073 return DECODING_AC_LOST;
1075 if(abs_level <= rl->max_level[last][run]*2){
1076 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1077 return DECODING_AC_LOST;
1079 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1080 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1081 return DECODING_AC_LOST;
1086 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1087 if (level>0) level= level * qmul + qadd;
1088 else level= level * qmul - qadd;
1089 #if 0 // waste of time too :(
1090 if(level>2048 || level<-2048){
1091 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1092 return DECODING_AC_LOST;
1097 #ifdef ERROR_DETAILS
1099 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1100 else if((i>62 && i<192) || i>192+63)
1101 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1105 SKIP_BITS(re, &s->gb, 2);
1106 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1107 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1108 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1109 LAST_SKIP_BITS(re, &s->gb, 1);
1110 #ifdef ERROR_DETAILS
1112 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1113 else if((i>62 && i<192) || i>192+63)
1114 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1119 SKIP_BITS(re, &s->gb, 1);
1120 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1122 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1123 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1124 LAST_SKIP_BITS(re, &s->gb, 1);
1125 #ifdef ERROR_DETAILS
1127 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1128 else if((i>62 && i<192) || i>192+63)
1129 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1134 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1135 LAST_SKIP_BITS(re, &s->gb, 1);
1136 #ifdef ERROR_DETAILS
1138 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1139 else if((i>62 && i<192) || i>192+63)
1140 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1146 const int left= get_bits_left(&s->gb);
1147 if(((i+192 == 64 && level/qmul==-1) || !(s->err_recognition&(AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && left>=0){
1148 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1151 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1156 block[scan_table[i]] = level;
1160 block[scan_table[i]] = level;
1162 CLOSE_READER(re, &s->gb);
1166 ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1168 i = 63; /* XXX: not optimal */
1171 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1172 s->block_last_index[n] = i;
1177 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1178 int *mx_ptr, int *my_ptr)
1183 mv = &ff_mv_tables[s->mv_table_index];
1185 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1187 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1190 if (code == mv->n) {
1191 mx = get_bits(&s->gb, 6);
1192 my = get_bits(&s->gb, 6);
1194 mx = mv->table_mvx[code];
1195 my = mv->table_mvy[code];
1200 /* WARNING : they do not do exactly modulo encoding */
1215 AVCodec ff_msmpeg4v1_decoder = {
1216 .name = "msmpeg4v1",
1217 .type = AVMEDIA_TYPE_VIDEO,
1218 .id = AV_CODEC_ID_MSMPEG4V1,
1219 .priv_data_size = sizeof(MpegEncContext),
1220 .init = ff_msmpeg4_decode_init,
1221 .close = ff_h263_decode_end,
1222 .decode = ff_h263_decode_frame,
1223 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1225 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1226 .pix_fmts = ff_pixfmt_list_420,
1229 AVCodec ff_msmpeg4v2_decoder = {
1230 .name = "msmpeg4v2",
1231 .type = AVMEDIA_TYPE_VIDEO,
1232 .id = AV_CODEC_ID_MSMPEG4V2,
1233 .priv_data_size = sizeof(MpegEncContext),
1234 .init = ff_msmpeg4_decode_init,
1235 .close = ff_h263_decode_end,
1236 .decode = ff_h263_decode_frame,
1237 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1239 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1240 .pix_fmts = ff_pixfmt_list_420,
1243 AVCodec ff_msmpeg4v3_decoder = {
1245 .type = AVMEDIA_TYPE_VIDEO,
1246 .id = AV_CODEC_ID_MSMPEG4V3,
1247 .priv_data_size = sizeof(MpegEncContext),
1248 .init = ff_msmpeg4_decode_init,
1249 .close = ff_h263_decode_end,
1250 .decode = ff_h263_decode_frame,
1251 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1253 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1254 .pix_fmts = ff_pixfmt_list_420,
1257 AVCodec ff_wmv1_decoder = {
1259 .type = AVMEDIA_TYPE_VIDEO,
1260 .id = AV_CODEC_ID_WMV1,
1261 .priv_data_size = sizeof(MpegEncContext),
1262 .init = ff_msmpeg4_decode_init,
1263 .close = ff_h263_decode_end,
1264 .decode = ff_h263_decode_frame,
1265 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1267 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1268 .pix_fmts = ff_pixfmt_list_420,