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){
1399 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1400 if(start_code!=0x00000100){
1401 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1405 skip_bits(&s->gb, 5); // frame number */
1408 s->pict_type = get_bits(&s->gb, 2) + 1;
1409 if (s->pict_type != FF_I_TYPE &&
1410 s->pict_type != FF_P_TYPE){
1411 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1417 if(s->pict_type == FF_I_TYPE) had_i=1;
1418 if(!had_i) return -1;
1421 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1423 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1427 if (s->pict_type == FF_I_TYPE) {
1428 code = get_bits(&s->gb, 5);
1429 if(s->msmpeg4_version==1){
1430 if(code==0 || code>s->mb_height){
1431 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1435 s->slice_height = code;
1437 /* 0x17: one slice, 0x18: two slices, ... */
1439 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1443 s->slice_height = s->mb_height / (code - 0x16);
1446 switch(s->msmpeg4_version){
1449 s->rl_chroma_table_index = 2;
1450 s->rl_table_index = 2;
1452 s->dc_table_index = 0; //not used
1455 s->rl_chroma_table_index = decode012(&s->gb);
1456 s->rl_table_index = decode012(&s->gb);
1458 s->dc_table_index = get_bits1(&s->gb);
1461 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1463 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1464 else s->per_mb_rl_table= 0;
1466 if(!s->per_mb_rl_table){
1467 s->rl_chroma_table_index = decode012(&s->gb);
1468 s->rl_table_index = decode012(&s->gb);
1471 s->dc_table_index = get_bits1(&s->gb);
1472 s->inter_intra_pred= 0;
1476 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1477 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1479 s->rl_chroma_table_index,
1485 switch(s->msmpeg4_version){
1488 if(s->msmpeg4_version==1)
1489 s->use_skip_mb_code = 1;
1491 s->use_skip_mb_code = get_bits1(&s->gb);
1492 s->rl_table_index = 2;
1493 s->rl_chroma_table_index = s->rl_table_index;
1494 s->dc_table_index = 0; //not used
1495 s->mv_table_index = 0;
1498 s->use_skip_mb_code = get_bits1(&s->gb);
1499 s->rl_table_index = decode012(&s->gb);
1500 s->rl_chroma_table_index = s->rl_table_index;
1502 s->dc_table_index = get_bits1(&s->gb);
1504 s->mv_table_index = get_bits1(&s->gb);
1507 s->use_skip_mb_code = get_bits1(&s->gb);
1509 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1510 else s->per_mb_rl_table= 0;
1512 if(!s->per_mb_rl_table){
1513 s->rl_table_index = decode012(&s->gb);
1514 s->rl_chroma_table_index = s->rl_table_index;
1517 s->dc_table_index = get_bits1(&s->gb);
1519 s->mv_table_index = get_bits1(&s->gb);
1520 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1524 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1525 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1526 s->use_skip_mb_code,
1528 s->rl_chroma_table_index,
1534 if(s->flipflop_rounding){
1535 s->no_rounding ^= 1;
1540 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1542 s->esc3_level_length= 0;
1543 s->esc3_run_length= 0;
1548 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1550 int left= buf_size*8 - get_bits_count(&s->gb);
1551 int length= s->msmpeg4_version>=3 ? 17 : 16;
1552 /* the alt_bitstream reader could read over the end so we need to check it */
1553 if(left>=length && left<length+8)
1557 fps= get_bits(&s->gb, 5);
1558 s->bit_rate= get_bits(&s->gb, 11)*1024;
1559 if(s->msmpeg4_version>=3)
1560 s->flipflop_rounding= get_bits1(&s->gb);
1562 s->flipflop_rounding= 0;
1564 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1566 else if(left<length+8)
1568 s->flipflop_rounding= 0;
1569 if(s->msmpeg4_version != 2)
1570 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1574 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1580 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1584 if(s->msmpeg4_version<=2){
1586 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1588 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1593 }else{ //FIXME optimize use unified tables & index
1595 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1597 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1600 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1604 if (level == DC_MAX) {
1605 level = get_bits(&s->gb, 8);
1606 if (get_bits1(&s->gb))
1608 } else if (level != 0) {
1609 if (get_bits1(&s->gb))
1614 if(s->msmpeg4_version==1){
1616 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1619 /* update predictor */
1623 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1626 /* update predictor */
1628 *dc_val = level * s->y_dc_scale;
1630 *dc_val = level * s->c_dc_scale;
1637 //#define ERROR_DETAILS
1638 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1639 int n, int coded, const uint8_t *scan_table)
1641 int level, i, last, run, run_diff;
1642 int av_uninit(dc_pred_dir);
1644 RL_VLC_ELEM *rl_vlc;
1652 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1655 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1656 if(s->inter_intra_pred) level=0;
1660 rl = &rl_table[s->rl_table_index];
1661 if(level > 256*s->y_dc_scale){
1662 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1663 if(!s->inter_intra_pred) return -1;
1666 rl = &rl_table[3 + s->rl_chroma_table_index];
1667 if(level > 256*s->c_dc_scale){
1668 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1669 if(!s->inter_intra_pred) return -1;
1674 run_diff = s->msmpeg4_version >= 4;
1680 if (dc_pred_dir == 0)
1681 scan_table = s->intra_v_scantable.permutated; /* left */
1683 scan_table = s->intra_h_scantable.permutated; /* top */
1685 scan_table = s->intra_scantable.permutated;
1687 rl_vlc= rl->rl_vlc[0];
1689 qmul = s->qscale << 1;
1690 qadd = (s->qscale - 1) | 1;
1692 rl = &rl_table[3 + s->rl_table_index];
1694 if(s->msmpeg4_version==2)
1700 s->block_last_index[n] = i;
1704 scan_table = s->inter_scantable.permutated;
1705 rl_vlc= rl->rl_vlc[s->qscale];
1708 OPEN_READER(re, &s->gb);
1710 UPDATE_CACHE(re, &s->gb);
1711 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1714 cache= GET_CACHE(re, &s->gb);
1716 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1717 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1719 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1720 UPDATE_CACHE(re, &s->gb);
1721 if(s->msmpeg4_version<=3){
1722 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1723 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1724 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1725 SKIP_COUNTER(re, &s->gb, 1+6+8);
1728 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1729 if(!s->esc3_level_length){
1731 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1733 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1735 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1739 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1741 SKIP_BITS(re, &s->gb, 1);
1743 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1746 s->esc3_level_length= ll;
1747 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1748 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1749 UPDATE_CACHE(re, &s->gb);
1751 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1752 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1754 sign= SHOW_UBITS(re, &s->gb, 1);
1755 SKIP_BITS(re, &s->gb, 1);
1757 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1758 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1759 if(sign) level= -level;
1761 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1762 #if 0 // waste of time / this will detect very few errors
1764 const int abs_level= FFABS(level);
1765 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1766 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1767 if(abs_level <= rl->max_level[last][run]){
1768 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1769 return DECODING_AC_LOST;
1771 if(abs_level <= rl->max_level[last][run]*2){
1772 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1773 return DECODING_AC_LOST;
1775 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1776 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1777 return DECODING_AC_LOST;
1782 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1783 if (level>0) level= level * qmul + qadd;
1784 else level= level * qmul - qadd;
1785 #if 0 // waste of time too :(
1786 if(level>2048 || level<-2048){
1787 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1788 return DECODING_AC_LOST;
1793 #ifdef ERROR_DETAILS
1795 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1796 else if((i>62 && i<192) || i>192+63)
1797 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1801 #if MIN_CACHE_BITS < 23
1802 LAST_SKIP_BITS(re, &s->gb, 2);
1803 UPDATE_CACHE(re, &s->gb);
1805 SKIP_BITS(re, &s->gb, 2);
1807 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1808 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1809 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1810 LAST_SKIP_BITS(re, &s->gb, 1);
1811 #ifdef ERROR_DETAILS
1813 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1814 else if((i>62 && i<192) || i>192+63)
1815 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1820 #if MIN_CACHE_BITS < 22
1821 LAST_SKIP_BITS(re, &s->gb, 1);
1822 UPDATE_CACHE(re, &s->gb);
1824 SKIP_BITS(re, &s->gb, 1);
1826 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1828 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1829 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1830 LAST_SKIP_BITS(re, &s->gb, 1);
1831 #ifdef ERROR_DETAILS
1833 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1834 else if((i>62 && i<192) || i>192+63)
1835 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1840 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1841 LAST_SKIP_BITS(re, &s->gb, 1);
1842 #ifdef ERROR_DETAILS
1844 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1845 else if((i>62 && i<192) || i>192+63)
1846 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1852 const int left= get_bits_left(&s->gb);
1853 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1854 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1857 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1862 block[scan_table[i]] = level;
1866 block[scan_table[i]] = level;
1868 CLOSE_READER(re, &s->gb);
1872 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1874 i = 63; /* XXX: not optimal */
1877 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1878 s->block_last_index[n] = i;
1883 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1884 int *mx_ptr, int *my_ptr)
1889 mv = &mv_tables[s->mv_table_index];
1891 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1893 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1896 if (code == mv->n) {
1897 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1898 mx = get_bits(&s->gb, 6);
1899 my = get_bits(&s->gb, 6);
1901 mx = mv->table_mvx[code];
1902 my = mv->table_mvy[code];
1907 /* WARNING : they do not do exactly modulo encoding */
1922 AVCodec msmpeg4v1_decoder = {
1926 sizeof(MpegEncContext),
1927 ff_msmpeg4_decode_init,
1930 ff_h263_decode_frame,
1931 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,
1946 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1947 .pix_fmts= ff_pixfmt_list_420,
1950 AVCodec msmpeg4v3_decoder = {
1954 sizeof(MpegEncContext),
1955 ff_msmpeg4_decode_init,
1958 ff_h263_decode_frame,
1959 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1960 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1961 .pix_fmts= ff_pixfmt_list_420,
1964 AVCodec wmv1_decoder = {
1968 sizeof(MpegEncContext),
1969 ff_msmpeg4_decode_init,
1972 ff_h263_decode_frame,
1973 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1974 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1975 .pix_fmts= ff_pixfmt_list_420,