2 * MSMPEG4 backend for ffmpeg 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 ffmpeg encoder and decoder.
32 #include "mpegvideo.h"
34 #include "libavutil/x86_cpu.h"
36 #include "mpeg4video.h"
39 * You can also call this codec : MPEG4 with a twist !
42 * - (encoding) select best mv table (two choices)
43 * - (encoding) select best vlc/dc table
48 #define V2_INTRA_CBPC_VLC_BITS 3
49 #define V2_MB_TYPE_VLC_BITS 7
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
54 #define II_BITRATE 128*1024
55 #define MBAC_BITRATE 50*1024
57 #define DEFAULT_INTER_INDEX 3
59 static uint32_t v2_dc_lum_table[512][2];
60 static uint32_t v2_dc_chroma_table[512][2];
63 extern const uint8_t wmv3_dc_scale_table[32];
69 #include "msmpeg4data.h"
71 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
72 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
73 #endif //CONFIG_ENCODERS
75 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
77 /* This table is practically identical to the one from h263
78 * except that it is inverted. */
79 static av_cold void init_h263_dc_for_msmpeg4(void)
81 int level, uni_code, uni_len;
83 for(level=-256; level<256; level++){
85 /* find number of bits */
94 l= (-level) ^ ((1 << size) - 1);
99 uni_code= ff_mpeg4_DCtab_lum[size][0];
100 uni_len = ff_mpeg4_DCtab_lum[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 v2_dc_lum_table[level+256][0]= uni_code;
112 v2_dc_lum_table[level+256][1]= uni_len;
114 /* chrominance h263 */
115 uni_code= ff_mpeg4_DCtab_chrom[size][0];
116 uni_len = ff_mpeg4_DCtab_chrom[size][1];
117 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
120 uni_code<<=size; uni_code|=l;
123 uni_code<<=1; uni_code|=1;
127 v2_dc_chroma_table[level+256][0]= uni_code;
128 v2_dc_chroma_table[level+256][1]= uni_len;
133 static av_cold void common_init(MpegEncContext * s)
135 static int initialized=0;
137 switch(s->msmpeg4_version){
141 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
144 if(s->workaround_bugs){
145 s->y_dc_scale_table= old_ff_y_dc_scale_table;
146 s->c_dc_scale_table= wmv1_c_dc_scale_table;
148 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
149 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
154 s->y_dc_scale_table= wmv1_y_dc_scale_table;
155 s->c_dc_scale_table= wmv1_c_dc_scale_table;
157 #if CONFIG_VC1_DECODER
159 s->y_dc_scale_table= wmv3_dc_scale_table;
160 s->c_dc_scale_table= wmv3_dc_scale_table;
167 if(s->msmpeg4_version>=4){
168 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
169 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
170 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
171 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
173 //Note the default tables are set in common_init in mpegvideo.c
178 init_h263_dc_for_msmpeg4();
184 /* build the table which associate a (x,y) motion vector to a vlc */
185 static void init_mv_table(MVTable *tab)
189 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
190 /* mark all entries as not used */
192 tab->table_mv_index[i] = tab->n;
194 for(i=0;i<tab->n;i++) {
195 x = tab->table_mvx[i];
196 y = tab->table_mvy[i];
197 tab->table_mv_index[(x << 6) | y] = i;
201 void ff_msmpeg4_code012(PutBitContext *pb, int n)
207 put_bits(pb, 1, (n >= 2));
211 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
214 int run_diff= intra ? 0 : 1;
216 code = get_rl_index(rl, last, run, level);
217 size+= rl->table_vlc[code][1];
221 level1 = level - rl->max_level[last][run];
224 code = get_rl_index(rl, last, run, level1);
228 if (level > MAX_LEVEL)
230 run1 = run - rl->max_run[last][level] - run_diff;
233 code = get_rl_index(rl, last, run1, level);
240 size+= 1+1+ rl->table_vlc[code][1];
244 size+= 1+1+ rl->table_vlc[code][1];
252 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
254 static int init_done=0;
258 if(s->msmpeg4_version>=4){
264 /* init various encoding tables */
266 init_mv_table(&mv_tables[0]);
267 init_mv_table(&mv_tables[1]);
268 for(i=0;i<NB_RL_TABLES;i++)
269 init_rl(&rl_table[i], static_rl_table_store[i]);
271 for(i=0; i<NB_RL_TABLES; i++){
273 for(level=0; level<=MAX_LEVEL; level++){
275 for(run=0; run<=MAX_RUN; run++){
277 for(last=0; last<2; last++){
278 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
286 static void find_best_tables(MpegEncContext * s)
289 int best =-1, best_size =9999999;
290 int chroma_best=-1, best_chroma_size=9999999;
301 for(level=0; level<=MAX_LEVEL; level++){
303 for(run=0; run<=MAX_RUN; run++){
305 const int last_size= size + chroma_size;
306 for(last=0; last<2; last++){
307 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
308 int intra_luma_count = s->ac_stats[1][0][level][run][last];
309 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
311 if(s->pict_type==FF_I_TYPE){
312 size += intra_luma_count *rl_length[i ][level][run][last];
313 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
315 size+= intra_luma_count *rl_length[i ][level][run][last]
316 +intra_chroma_count*rl_length[i+3][level][run][last]
317 +inter_count *rl_length[i+3][level][run][last];
320 if(last_size == size+chroma_size) break;
327 if(chroma_size<best_chroma_size){
328 best_chroma_size= chroma_size;
333 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
334 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
336 if(s->pict_type==FF_P_TYPE) chroma_best= best;
338 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
340 s->rl_table_index = best;
341 s->rl_chroma_table_index= chroma_best;
343 if(s->pict_type != s->last_non_b_pict_type){
344 s->rl_table_index= 2;
345 if(s->pict_type==FF_I_TYPE)
346 s->rl_chroma_table_index= 1;
348 s->rl_chroma_table_index= 2;
353 /* write MSMPEG4 compatible frame header */
354 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
358 align_put_bits(&s->pb);
359 put_bits(&s->pb, 2, s->pict_type - 1);
361 put_bits(&s->pb, 5, s->qscale);
362 if(s->msmpeg4_version<=2){
363 s->rl_table_index = 2;
364 s->rl_chroma_table_index = 2;
367 s->dc_table_index = 1;
368 s->mv_table_index = 1; /* only if P frame */
369 s->use_skip_mb_code = 1; /* only if P frame */
370 s->per_mb_rl_table = 0;
371 if(s->msmpeg4_version==4)
372 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
373 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
375 if (s->pict_type == FF_I_TYPE) {
376 s->slice_height= s->mb_height/1;
377 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
379 if(s->msmpeg4_version==4){
380 msmpeg4_encode_ext_header(s);
381 if(s->bit_rate>MBAC_BITRATE)
382 put_bits(&s->pb, 1, s->per_mb_rl_table);
385 if(s->msmpeg4_version>2){
386 if(!s->per_mb_rl_table){
387 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
388 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
391 put_bits(&s->pb, 1, s->dc_table_index);
394 put_bits(&s->pb, 1, s->use_skip_mb_code);
396 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
397 put_bits(&s->pb, 1, s->per_mb_rl_table);
399 if(s->msmpeg4_version>2){
400 if(!s->per_mb_rl_table)
401 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
403 put_bits(&s->pb, 1, s->dc_table_index);
405 put_bits(&s->pb, 1, s->mv_table_index);
409 s->esc3_level_length= 0;
410 s->esc3_run_length= 0;
413 void msmpeg4_encode_ext_header(MpegEncContext * s)
415 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
417 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
419 if(s->msmpeg4_version>=3)
420 put_bits(&s->pb, 1, s->flipflop_rounding);
422 assert(s->flipflop_rounding==0);
425 #endif //CONFIG_ENCODERS
427 /* predict coded block */
428 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
430 int xy, wrap, pred, a, b, c;
432 xy = s->block_index[n];
438 a = s->coded_block[xy - 1 ];
439 b = s->coded_block[xy - 1 - wrap];
440 c = s->coded_block[xy - wrap];
449 *coded_block_ptr = &s->coded_block[xy];
456 void ff_msmpeg4_encode_motion(MpegEncContext * s,
462 /* modulo encoding */
463 /* WARNING : you cannot reach all the MVs even with the modulo
464 encoding. This is a somewhat strange compromise they took !!! */
477 if ((unsigned)mx >= 64 ||
479 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
481 mv = &mv_tables[s->mv_table_index];
483 code = mv->table_mv_index[(mx << 6) | my];
485 mv->table_mv_bits[code],
486 mv->table_mv_code[code]);
488 /* escape : code literally */
489 put_bits(&s->pb, 6, mx);
490 put_bits(&s->pb, 6, my);
494 void ff_msmpeg4_handle_slices(MpegEncContext *s){
496 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
497 if(s->msmpeg4_version < 4){
498 ff_mpeg4_clean_buffers(s);
500 s->first_slice_line = 1;
502 s->first_slice_line = 0;
507 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
509 int range, bit_size, sign, code, bits;
514 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
516 bit_size = s->f_code - 1;
517 range = 1 << bit_size;
530 code = (val >> bit_size) + 1;
531 bits = val & (range - 1);
533 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
535 put_bits(&s->pb, bit_size, bits);
540 void msmpeg4_encode_mb(MpegEncContext * s,
541 DCTELEM block[6][64],
542 int motion_x, int motion_y)
544 int cbp, coded_cbp, i;
546 uint8_t *coded_block;
548 ff_msmpeg4_handle_slices(s);
553 for (i = 0; i < 6; i++) {
554 if (s->block_last_index[i] >= 0)
557 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
558 /* skip macroblock */
559 put_bits(&s->pb, 1, 1);
566 if (s->use_skip_mb_code)
567 put_bits(&s->pb, 1, 0); /* mb coded */
569 if(s->msmpeg4_version<=2){
571 v2_mb_type[cbp&3][1],
572 v2_mb_type[cbp&3][0]);
573 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
577 ff_h263_cbpy_tab[coded_cbp>>2][1],
578 ff_h263_cbpy_tab[coded_cbp>>2][0]);
580 s->misc_bits += get_bits_diff(s);
582 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
583 msmpeg4v2_encode_motion(s, motion_x - pred_x);
584 msmpeg4v2_encode_motion(s, motion_y - pred_y);
587 table_mb_non_intra[cbp + 64][1],
588 table_mb_non_intra[cbp + 64][0]);
590 s->misc_bits += get_bits_diff(s);
593 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
594 ff_msmpeg4_encode_motion(s, motion_x - pred_x,
598 s->mv_bits += get_bits_diff(s);
600 for (i = 0; i < 6; i++) {
601 ff_msmpeg4_encode_block(s, block[i], i);
603 s->p_tex_bits += get_bits_diff(s);
608 for (i = 0; i < 6; i++) {
610 val = (s->block_last_index[i] >= 1);
611 cbp |= val << (5 - i);
613 /* predict value for close blocks only for luma */
614 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
618 coded_cbp |= val << (5 - i);
622 printf("cbp=%x %x\n", cbp, coded_cbp);
625 if(s->msmpeg4_version<=2){
626 if (s->pict_type == FF_I_TYPE) {
628 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
630 if (s->use_skip_mb_code)
631 put_bits(&s->pb, 1, 0); /* mb coded */
633 v2_mb_type[(cbp&3) + 4][1],
634 v2_mb_type[(cbp&3) + 4][0]);
636 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
638 ff_h263_cbpy_tab[cbp>>2][1],
639 ff_h263_cbpy_tab[cbp>>2][0]);
641 if (s->pict_type == FF_I_TYPE) {
643 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
645 if (s->use_skip_mb_code)
646 put_bits(&s->pb, 1, 0); /* mb coded */
648 table_mb_non_intra[cbp][1],
649 table_mb_non_intra[cbp][0]);
651 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
652 if(s->inter_intra_pred){
654 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
657 s->misc_bits += get_bits_diff(s);
659 for (i = 0; i < 6; i++) {
660 ff_msmpeg4_encode_block(s, block[i], i);
662 s->i_tex_bits += get_bits_diff(s);
667 #endif //CONFIG_ENCODERS
669 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
670 int32_t **dc_val_ptr)
680 *dc_val_ptr= &s->last_dc[i];
681 return s->last_dc[i];
684 static int get_dc(uint8_t *src, int stride, int scale)
691 sum+=src[x + y*stride];
694 return FASTDIV((sum + (scale>>1)), scale);
697 /* dir = 0: left, dir = 1: top prediction */
698 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
699 int16_t **dc_val_ptr, int *dir_ptr)
701 int a, b, c, wrap, pred, scale;
704 /* find prediction */
706 scale = s->y_dc_scale;
708 scale = s->c_dc_scale;
711 wrap = s->block_wrap[n];
712 dc_val= s->dc_val[0] + s->block_index[n];
718 b = dc_val[ - 1 - wrap];
721 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
725 /* XXX: the following solution consumes divisions, but it does not
726 necessitate to modify mpegvideo.c. The problem comes from the
727 fact they decided to store the quantized DC (which would lead
728 to problems if Q could vary !) */
729 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
731 "movl %3, %%eax \n\t"
732 "shrl $1, %%eax \n\t"
733 "addl %%eax, %2 \n\t"
734 "addl %%eax, %1 \n\t"
735 "addl %0, %%eax \n\t"
737 "movl %%edx, %0 \n\t"
738 "movl %1, %%eax \n\t"
740 "movl %%edx, %1 \n\t"
741 "movl %2, %%eax \n\t"
743 "movl %%edx, %2 \n\t"
744 : "+b" (a), "+c" (b), "+D" (c)
745 : "g" (scale), "S" (ff_inverse[scale])
749 /* #elif ARCH_ALPHA */
750 /* Divisions are extremely costly on Alpha; optimize the most
751 common case. But they are costly everywhere...
754 a = (a + (8 >> 1)) / 8;
755 b = (b + (8 >> 1)) / 8;
756 c = (c + (8 >> 1)) / 8;
758 a = FASTDIV((a + (scale >> 1)), scale);
759 b = FASTDIV((b + (scale >> 1)), scale);
760 c = FASTDIV((c + (scale >> 1)), scale);
763 /* XXX: WARNING: they did not choose the same test as MPEG4. This
764 is very important ! */
765 if(s->msmpeg4_version>3){
766 if(s->inter_intra_pred){
777 if (abs(a - b) < abs(b - c)) {
787 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
790 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
792 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
793 else a= get_dc(dest-8, wrap, scale*8);
794 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
795 else c= get_dc(dest-8*wrap, wrap, scale*8);
797 if (s->h263_aic_dir==0) {
800 }else if (s->h263_aic_dir==1) {
808 }else if (s->h263_aic_dir==2) {
822 if (abs(a - b) < abs(b - c)) {
831 if (abs(a - b) <= abs(b - c)) {
840 /* update predictor */
841 *dc_val_ptr = &dc_val[0];
847 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
853 if(s->msmpeg4_version==1){
855 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
857 /* update predictor */
861 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
863 /* update predictor */
865 *dc_val = level * s->y_dc_scale;
867 *dc_val = level * s->c_dc_scale;
871 /* do the prediction */
874 if(s->msmpeg4_version<=2){
877 v2_dc_lum_table[level+256][1],
878 v2_dc_lum_table[level+256][0]);
881 v2_dc_chroma_table[level+256][1],
882 v2_dc_chroma_table[level+256][0]);
893 else if( s->msmpeg4_version>=6 ) {
894 if( s->qscale == 1 ) {
895 extquant = (level + 3) & 0x3;
896 code = ((level+3)>>2);
897 } else if( s->qscale == 2 ) {
898 extquant = (level + 1) & 0x1;
899 code = ((level+1)>>1);
903 if (s->dc_table_index == 0) {
905 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
907 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
911 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
913 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
917 if(s->msmpeg4_version>=6 && s->qscale<=2)
918 extrabits = 3 - s->qscale;
921 put_bits(&s->pb, 8 + extrabits, level);
922 else if(extrabits > 0)//== VC1 && s->qscale<=2
923 put_bits(&s->pb, extrabits, extquant);
926 put_bits(&s->pb, 1, sign);
931 /* Encoding of a block. Very similar to MPEG4 except for a different
932 escape coding (same as H263) and more vlc tables.
934 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
936 int level, run, last, i, j, last_index;
937 int last_non_zero, sign, slevel;
938 int code, run_diff, dc_pred_dir;
940 const uint8_t *scantable;
943 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
946 rl = &rl_table[s->rl_table_index];
948 rl = &rl_table[3 + s->rl_chroma_table_index];
950 run_diff = s->msmpeg4_version>=4;
951 scantable= s->intra_scantable.permutated;
954 rl = &rl_table[3 + s->rl_table_index];
955 if(s->msmpeg4_version<=2)
959 scantable= s->inter_scantable.permutated;
962 /* recalculate block_last_index for M$ wmv1 */
963 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
964 for(last_index=63; last_index>=0; last_index--){
965 if(block[scantable[last_index]]) break;
967 s->block_last_index[n]= last_index;
969 last_index = s->block_last_index[n];
971 last_non_zero = i - 1;
972 for (; i <= last_index; i++) {
976 run = i - last_non_zero - 1;
977 last = (i == last_index);
985 if(level<=MAX_LEVEL && run<=MAX_RUN){
986 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
990 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
992 code = get_rl_index(rl, last, run, level);
993 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
997 level1 = level - rl->max_level[last][run];
1000 code = get_rl_index(rl, last, run, level1);
1001 if (code == rl->n) {
1003 put_bits(&s->pb, 1, 0);
1004 if (level > MAX_LEVEL)
1006 run1 = run - rl->max_run[last][level] - run_diff;
1009 code = get_rl_index(rl, last, run1+1, level);
1010 if (s->msmpeg4_version == 4 && code == rl->n)
1012 code = get_rl_index(rl, last, run1, level);
1013 if (code == rl->n) {
1016 put_bits(&s->pb, 1, 0);
1017 put_bits(&s->pb, 1, last);
1018 if(s->msmpeg4_version>=4){
1019 if(s->esc3_level_length==0){
1020 s->esc3_level_length=8;
1021 s->esc3_run_length= 6;
1022 //ESCLVLSZ + ESCRUNSZ
1024 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1026 put_bits(&s->pb, 8, 3);
1028 put_bits(&s->pb, s->esc3_run_length, run);
1029 put_bits(&s->pb, 1, sign);
1030 put_bits(&s->pb, s->esc3_level_length, level);
1032 put_bits(&s->pb, 6, run);
1033 put_sbits(&s->pb, 8, slevel);
1037 put_bits(&s->pb, 1, 1);
1038 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1039 put_bits(&s->pb, 1, sign);
1043 put_bits(&s->pb, 1, 1);
1044 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1045 put_bits(&s->pb, 1, sign);
1048 put_bits(&s->pb, 1, sign);
1055 /****************************************/
1056 /* decoding stuff */
1058 VLC ff_mb_non_intra_vlc[4];
1059 static VLC v2_dc_lum_vlc;
1060 static VLC v2_dc_chroma_vlc;
1061 static VLC v2_intra_cbpc_vlc;
1062 static VLC v2_mb_type_vlc;
1063 static VLC v2_mv_vlc;
1064 VLC ff_inter_intra_vlc;
1066 /* This is identical to h263 except that its range is multiplied by 2. */
1067 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1069 int code, val, sign, shift;
1071 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1072 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1078 sign = get_bits1(&s->gb);
1082 val = (val - 1) << shift;
1083 val |= get_bits(&s->gb, shift);
1098 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1102 if (s->pict_type == FF_P_TYPE) {
1103 if (s->use_skip_mb_code) {
1104 if (get_bits1(&s->gb)) {
1108 s->block_last_index[i] = -1;
1109 s->mv_dir = MV_DIR_FORWARD;
1110 s->mv_type = MV_TYPE_16X16;
1118 if(s->msmpeg4_version==2)
1119 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1121 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1122 if(code<0 || code>7){
1123 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1127 s->mb_intra = code >>2;
1132 if(s->msmpeg4_version==2)
1133 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1135 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1137 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1145 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1147 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1152 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1154 h263_pred_motion(s, 0, 0, &mx, &my);
1155 mx= msmpeg4v2_decode_motion(s, mx, 1);
1156 my= msmpeg4v2_decode_motion(s, my, 1);
1158 s->mv_dir = MV_DIR_FORWARD;
1159 s->mv_type = MV_TYPE_16X16;
1160 s->mv[0][0][0] = mx;
1161 s->mv[0][0][1] = my;
1163 if(s->msmpeg4_version==2){
1164 s->ac_pred = get_bits1(&s->gb);
1165 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1168 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1169 if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1173 s->dsp.clear_blocks(s->block[0]);
1174 for (i = 0; i < 6; i++) {
1175 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1177 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1184 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1188 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1190 if (s->pict_type == FF_P_TYPE) {
1191 if (s->use_skip_mb_code) {
1192 if (get_bits1(&s->gb)) {
1196 s->block_last_index[i] = -1;
1197 s->mv_dir = MV_DIR_FORWARD;
1198 s->mv_type = MV_TYPE_16X16;
1202 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1208 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1211 //s->mb_intra = (code & 0x40) ? 0 : 1;
1212 s->mb_intra = (~code & 0x40) >> 6;
1217 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1220 /* predict coded block pattern */
1223 int val = ((code >> (5 - i)) & 1);
1225 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1229 cbp |= val << (5 - i);
1235 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1236 if(s->per_mb_rl_table && cbp){
1237 s->rl_table_index = decode012(&s->gb);
1238 s->rl_chroma_table_index = s->rl_table_index;
1240 h263_pred_motion(s, 0, 0, &mx, &my);
1241 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1243 s->mv_dir = MV_DIR_FORWARD;
1244 s->mv_type = MV_TYPE_16X16;
1245 s->mv[0][0][0] = mx;
1246 s->mv[0][0][1] = my;
1247 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1249 //printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
1250 s->ac_pred = get_bits1(&s->gb);
1251 *mb_type_ptr = MB_TYPE_INTRA;
1252 if(s->inter_intra_pred){
1253 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1254 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1256 if(s->per_mb_rl_table && cbp){
1257 s->rl_table_index = decode012(&s->gb);
1258 s->rl_chroma_table_index = s->rl_table_index;
1262 s->dsp.clear_blocks(s->block[0]);
1263 for (i = 0; i < 6; i++) {
1264 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1266 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1274 /* init all vlc decoding tables */
1275 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1277 MpegEncContext *s = avctx->priv_data;
1278 static int done = 0;
1282 ff_h263_decode_init(avctx);
1289 for(i=0;i<NB_RL_TABLES;i++) {
1290 init_rl(&rl_table[i], static_rl_table_store[i]);
1292 INIT_VLC_RL(rl_table[0], 642);
1293 INIT_VLC_RL(rl_table[1], 1104);
1294 INIT_VLC_RL(rl_table[2], 554);
1295 INIT_VLC_RL(rl_table[3], 940);
1296 INIT_VLC_RL(rl_table[4], 962);
1297 INIT_VLC_RL(rl_table[5], 554);
1300 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1301 mv->table_mv_bits, 1, 1,
1302 mv->table_mv_code, 2, 2, 3714);
1304 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1305 mv->table_mv_bits, 1, 1,
1306 mv->table_mv_code, 2, 2, 2694);
1308 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1309 &ff_table0_dc_lum[0][1], 8, 4,
1310 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1311 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1312 &ff_table0_dc_chroma[0][1], 8, 4,
1313 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1314 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1315 &ff_table1_dc_lum[0][1], 8, 4,
1316 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1317 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1318 &ff_table1_dc_chroma[0][1], 8, 4,
1319 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1321 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1322 &v2_dc_lum_table[0][1], 8, 4,
1323 &v2_dc_lum_table[0][0], 8, 4, 1472);
1324 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1325 &v2_dc_chroma_table[0][1], 8, 4,
1326 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1328 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1329 &v2_intra_cbpc[0][1], 2, 1,
1330 &v2_intra_cbpc[0][0], 2, 1, 8);
1331 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1332 &v2_mb_type[0][1], 2, 1,
1333 &v2_mb_type[0][0], 2, 1, 128);
1334 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1336 &mvtab[0][0], 2, 1, 538);
1338 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1339 &wmv2_inter_table[0][0][1], 8, 4,
1340 &wmv2_inter_table[0][0][0], 8, 4, 1636);
1341 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1342 &wmv2_inter_table[1][0][1], 8, 4,
1343 &wmv2_inter_table[1][0][0], 8, 4, 2648);
1344 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1345 &wmv2_inter_table[2][0][1], 8, 4,
1346 &wmv2_inter_table[2][0][0], 8, 4, 1532);
1347 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1348 &wmv2_inter_table[3][0][1], 8, 4,
1349 &wmv2_inter_table[3][0][0], 8, 4, 2488);
1351 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1352 &ff_msmp4_mb_i_table[0][1], 4, 2,
1353 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1355 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1356 &table_inter_intra[0][1], 2, 1,
1357 &table_inter_intra[0][0], 2, 1, 8);
1360 switch(s->msmpeg4_version){
1363 s->decode_mb= msmpeg4v12_decode_mb;
1367 s->decode_mb= msmpeg4v34_decode_mb;
1370 if (CONFIG_WMV2_DECODER)
1371 s->decode_mb= ff_wmv2_decode_mb;
1373 //FIXME + TODO VC1 decode mb
1377 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1382 int msmpeg4_decode_picture_header(MpegEncContext * s)
1389 for(i=0; i<s->gb.size_in_bits; i++)
1390 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1391 // get_bits1(&s->gb);
1392 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1397 if(s->msmpeg4_version==1){
1398 int start_code = get_bits_long(&s->gb, 32);
1399 if(start_code!=0x00000100){
1400 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1404 skip_bits(&s->gb, 5); // frame number */
1407 s->pict_type = get_bits(&s->gb, 2) + 1;
1408 if (s->pict_type != FF_I_TYPE &&
1409 s->pict_type != FF_P_TYPE){
1410 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1416 if(s->pict_type == FF_I_TYPE) had_i=1;
1417 if(!had_i) return -1;
1420 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1422 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1426 if (s->pict_type == FF_I_TYPE) {
1427 code = get_bits(&s->gb, 5);
1428 if(s->msmpeg4_version==1){
1429 if(code==0 || code>s->mb_height){
1430 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1434 s->slice_height = code;
1436 /* 0x17: one slice, 0x18: two slices, ... */
1438 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1442 s->slice_height = s->mb_height / (code - 0x16);
1445 switch(s->msmpeg4_version){
1448 s->rl_chroma_table_index = 2;
1449 s->rl_table_index = 2;
1451 s->dc_table_index = 0; //not used
1454 s->rl_chroma_table_index = decode012(&s->gb);
1455 s->rl_table_index = decode012(&s->gb);
1457 s->dc_table_index = get_bits1(&s->gb);
1460 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1462 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1463 else s->per_mb_rl_table= 0;
1465 if(!s->per_mb_rl_table){
1466 s->rl_chroma_table_index = decode012(&s->gb);
1467 s->rl_table_index = decode012(&s->gb);
1470 s->dc_table_index = get_bits1(&s->gb);
1471 s->inter_intra_pred= 0;
1475 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1476 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1478 s->rl_chroma_table_index,
1484 switch(s->msmpeg4_version){
1487 if(s->msmpeg4_version==1)
1488 s->use_skip_mb_code = 1;
1490 s->use_skip_mb_code = get_bits1(&s->gb);
1491 s->rl_table_index = 2;
1492 s->rl_chroma_table_index = s->rl_table_index;
1493 s->dc_table_index = 0; //not used
1494 s->mv_table_index = 0;
1497 s->use_skip_mb_code = get_bits1(&s->gb);
1498 s->rl_table_index = decode012(&s->gb);
1499 s->rl_chroma_table_index = s->rl_table_index;
1501 s->dc_table_index = get_bits1(&s->gb);
1503 s->mv_table_index = get_bits1(&s->gb);
1506 s->use_skip_mb_code = get_bits1(&s->gb);
1508 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1509 else s->per_mb_rl_table= 0;
1511 if(!s->per_mb_rl_table){
1512 s->rl_table_index = decode012(&s->gb);
1513 s->rl_chroma_table_index = s->rl_table_index;
1516 s->dc_table_index = get_bits1(&s->gb);
1518 s->mv_table_index = get_bits1(&s->gb);
1519 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1523 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1524 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1525 s->use_skip_mb_code,
1527 s->rl_chroma_table_index,
1533 if(s->flipflop_rounding){
1534 s->no_rounding ^= 1;
1539 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1541 s->esc3_level_length= 0;
1542 s->esc3_run_length= 0;
1547 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1549 int left= buf_size*8 - get_bits_count(&s->gb);
1550 int length= s->msmpeg4_version>=3 ? 17 : 16;
1551 /* the alt_bitstream reader could read over the end so we need to check it */
1552 if(left>=length && left<length+8)
1556 fps= get_bits(&s->gb, 5);
1557 s->bit_rate= get_bits(&s->gb, 11)*1024;
1558 if(s->msmpeg4_version>=3)
1559 s->flipflop_rounding= get_bits1(&s->gb);
1561 s->flipflop_rounding= 0;
1563 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1565 else if(left<length+8)
1567 s->flipflop_rounding= 0;
1568 if(s->msmpeg4_version != 2)
1569 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1573 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1579 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1583 if(s->msmpeg4_version<=2){
1585 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1587 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1592 }else{ //FIXME optimize use unified tables & index
1594 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1596 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1599 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1603 if (level == DC_MAX) {
1604 level = get_bits(&s->gb, 8);
1605 if (get_bits1(&s->gb))
1607 } else if (level != 0) {
1608 if (get_bits1(&s->gb))
1613 if(s->msmpeg4_version==1){
1615 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1618 /* update predictor */
1622 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1625 /* update predictor */
1627 *dc_val = level * s->y_dc_scale;
1629 *dc_val = level * s->c_dc_scale;
1636 //#define ERROR_DETAILS
1637 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1638 int n, int coded, const uint8_t *scan_table)
1640 int level, i, last, run, run_diff;
1641 int av_uninit(dc_pred_dir);
1643 RL_VLC_ELEM *rl_vlc;
1651 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1654 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1655 if(s->inter_intra_pred) level=0;
1659 rl = &rl_table[s->rl_table_index];
1660 if(level > 256*s->y_dc_scale){
1661 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1662 if(!s->inter_intra_pred) return -1;
1665 rl = &rl_table[3 + s->rl_chroma_table_index];
1666 if(level > 256*s->c_dc_scale){
1667 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1668 if(!s->inter_intra_pred) return -1;
1673 run_diff = s->msmpeg4_version >= 4;
1679 if (dc_pred_dir == 0)
1680 scan_table = s->intra_v_scantable.permutated; /* left */
1682 scan_table = s->intra_h_scantable.permutated; /* top */
1684 scan_table = s->intra_scantable.permutated;
1686 rl_vlc= rl->rl_vlc[0];
1688 qmul = s->qscale << 1;
1689 qadd = (s->qscale - 1) | 1;
1691 rl = &rl_table[3 + s->rl_table_index];
1693 if(s->msmpeg4_version==2)
1699 s->block_last_index[n] = i;
1703 scan_table = s->inter_scantable.permutated;
1704 rl_vlc= rl->rl_vlc[s->qscale];
1707 OPEN_READER(re, &s->gb);
1709 UPDATE_CACHE(re, &s->gb);
1710 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1713 cache= GET_CACHE(re, &s->gb);
1715 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1716 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1718 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1719 UPDATE_CACHE(re, &s->gb);
1720 if(s->msmpeg4_version<=3){
1721 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1722 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1723 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1724 SKIP_COUNTER(re, &s->gb, 1+6+8);
1727 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1728 if(!s->esc3_level_length){
1730 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1732 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1734 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1738 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1740 SKIP_BITS(re, &s->gb, 1);
1742 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1745 s->esc3_level_length= ll;
1746 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1747 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1748 UPDATE_CACHE(re, &s->gb);
1750 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1751 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1753 sign= SHOW_UBITS(re, &s->gb, 1);
1754 SKIP_BITS(re, &s->gb, 1);
1756 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1757 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1758 if(sign) level= -level;
1760 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1761 #if 0 // waste of time / this will detect very few errors
1763 const int abs_level= FFABS(level);
1764 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1765 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1766 if(abs_level <= rl->max_level[last][run]){
1767 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1768 return DECODING_AC_LOST;
1770 if(abs_level <= rl->max_level[last][run]*2){
1771 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1772 return DECODING_AC_LOST;
1774 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1775 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1776 return DECODING_AC_LOST;
1781 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1782 if (level>0) level= level * qmul + qadd;
1783 else level= level * qmul - qadd;
1784 #if 0 // waste of time too :(
1785 if(level>2048 || level<-2048){
1786 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1787 return DECODING_AC_LOST;
1792 #ifdef ERROR_DETAILS
1794 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1795 else if((i>62 && i<192) || i>192+63)
1796 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1800 #if MIN_CACHE_BITS < 23
1801 LAST_SKIP_BITS(re, &s->gb, 2);
1802 UPDATE_CACHE(re, &s->gb);
1804 SKIP_BITS(re, &s->gb, 2);
1806 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1807 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1808 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1809 LAST_SKIP_BITS(re, &s->gb, 1);
1810 #ifdef ERROR_DETAILS
1812 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1813 else if((i>62 && i<192) || i>192+63)
1814 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1819 #if MIN_CACHE_BITS < 22
1820 LAST_SKIP_BITS(re, &s->gb, 1);
1821 UPDATE_CACHE(re, &s->gb);
1823 SKIP_BITS(re, &s->gb, 1);
1825 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1827 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1828 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1829 LAST_SKIP_BITS(re, &s->gb, 1);
1830 #ifdef ERROR_DETAILS
1832 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1833 else if((i>62 && i<192) || i>192+63)
1834 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1839 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1840 LAST_SKIP_BITS(re, &s->gb, 1);
1841 #ifdef ERROR_DETAILS
1843 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1844 else if((i>62 && i<192) || i>192+63)
1845 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1851 const int left= get_bits_left(&s->gb);
1852 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1853 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1856 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1861 block[scan_table[i]] = level;
1865 block[scan_table[i]] = level;
1867 CLOSE_READER(re, &s->gb);
1871 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1873 i = 63; /* XXX: not optimal */
1876 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1877 s->block_last_index[n] = i;
1882 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1883 int *mx_ptr, int *my_ptr)
1888 mv = &mv_tables[s->mv_table_index];
1890 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1892 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1895 if (code == mv->n) {
1896 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1897 mx = get_bits(&s->gb, 6);
1898 my = get_bits(&s->gb, 6);
1900 mx = mv->table_mvx[code];
1901 my = mv->table_mvy[code];
1906 /* WARNING : they do not do exactly modulo encoding */
1921 AVCodec msmpeg4v1_decoder = {
1925 sizeof(MpegEncContext),
1926 ff_msmpeg4_decode_init,
1929 ff_h263_decode_frame,
1930 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1932 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1933 .pix_fmts= ff_pixfmt_list_420,
1936 AVCodec msmpeg4v2_decoder = {
1940 sizeof(MpegEncContext),
1941 ff_msmpeg4_decode_init,
1944 ff_h263_decode_frame,
1945 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1947 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1948 .pix_fmts= ff_pixfmt_list_420,
1951 AVCodec msmpeg4v3_decoder = {
1955 sizeof(MpegEncContext),
1956 ff_msmpeg4_decode_init,
1959 ff_h263_decode_frame,
1960 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1962 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1963 .pix_fmts= ff_pixfmt_list_420,
1966 AVCodec wmv1_decoder = {
1970 sizeof(MpegEncContext),
1971 ff_msmpeg4_decode_init,
1974 ff_h263_decode_frame,
1975 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1977 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1978 .pix_fmts= ff_pixfmt_list_420,