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 Libav.
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * MSMPEG4 backend for 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]++;
989 s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
991 code = get_rl_index(rl, last, run, level);
992 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
996 level1 = level - rl->max_level[last][run];
999 code = get_rl_index(rl, last, run, level1);
1000 if (code == rl->n) {
1002 put_bits(&s->pb, 1, 0);
1003 if (level > MAX_LEVEL)
1005 run1 = run - rl->max_run[last][level] - run_diff;
1008 code = get_rl_index(rl, last, run1+1, level);
1009 if (s->msmpeg4_version == 4 && code == rl->n)
1011 code = get_rl_index(rl, last, run1, level);
1012 if (code == rl->n) {
1015 put_bits(&s->pb, 1, 0);
1016 put_bits(&s->pb, 1, last);
1017 if(s->msmpeg4_version>=4){
1018 if(s->esc3_level_length==0){
1019 s->esc3_level_length=8;
1020 s->esc3_run_length= 6;
1021 //ESCLVLSZ + ESCRUNSZ
1023 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1025 put_bits(&s->pb, 8, 3);
1027 put_bits(&s->pb, s->esc3_run_length, run);
1028 put_bits(&s->pb, 1, sign);
1029 put_bits(&s->pb, s->esc3_level_length, level);
1031 put_bits(&s->pb, 6, run);
1032 put_sbits(&s->pb, 8, slevel);
1036 put_bits(&s->pb, 1, 1);
1037 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1038 put_bits(&s->pb, 1, sign);
1042 put_bits(&s->pb, 1, 1);
1043 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1044 put_bits(&s->pb, 1, sign);
1047 put_bits(&s->pb, 1, sign);
1054 /****************************************/
1055 /* decoding stuff */
1057 VLC ff_mb_non_intra_vlc[4];
1058 static VLC v2_dc_lum_vlc;
1059 static VLC v2_dc_chroma_vlc;
1060 static VLC v2_intra_cbpc_vlc;
1061 static VLC v2_mb_type_vlc;
1062 static VLC v2_mv_vlc;
1063 VLC ff_inter_intra_vlc;
1065 /* This is identical to h263 except that its range is multiplied by 2. */
1066 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1068 int code, val, sign, shift;
1070 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1071 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1077 sign = get_bits1(&s->gb);
1081 val = (val - 1) << shift;
1082 val |= get_bits(&s->gb, shift);
1097 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1101 if (s->pict_type == FF_P_TYPE) {
1102 if (s->use_skip_mb_code) {
1103 if (get_bits1(&s->gb)) {
1107 s->block_last_index[i] = -1;
1108 s->mv_dir = MV_DIR_FORWARD;
1109 s->mv_type = MV_TYPE_16X16;
1117 if(s->msmpeg4_version==2)
1118 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1120 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1121 if(code<0 || code>7){
1122 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1126 s->mb_intra = code >>2;
1131 if(s->msmpeg4_version==2)
1132 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1134 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1136 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1144 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1146 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1151 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1153 h263_pred_motion(s, 0, 0, &mx, &my);
1154 mx= msmpeg4v2_decode_motion(s, mx, 1);
1155 my= msmpeg4v2_decode_motion(s, my, 1);
1157 s->mv_dir = MV_DIR_FORWARD;
1158 s->mv_type = MV_TYPE_16X16;
1159 s->mv[0][0][0] = mx;
1160 s->mv[0][0][1] = my;
1162 if(s->msmpeg4_version==2){
1163 s->ac_pred = get_bits1(&s->gb);
1164 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1167 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1168 if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1172 s->dsp.clear_blocks(s->block[0]);
1173 for (i = 0; i < 6; i++) {
1174 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1176 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1183 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1187 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1189 if (s->pict_type == FF_P_TYPE) {
1190 if (s->use_skip_mb_code) {
1191 if (get_bits1(&s->gb)) {
1195 s->block_last_index[i] = -1;
1196 s->mv_dir = MV_DIR_FORWARD;
1197 s->mv_type = MV_TYPE_16X16;
1201 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1207 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1210 //s->mb_intra = (code & 0x40) ? 0 : 1;
1211 s->mb_intra = (~code & 0x40) >> 6;
1216 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1219 /* predict coded block pattern */
1222 int val = ((code >> (5 - i)) & 1);
1224 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1228 cbp |= val << (5 - i);
1234 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1235 if(s->per_mb_rl_table && cbp){
1236 s->rl_table_index = decode012(&s->gb);
1237 s->rl_chroma_table_index = s->rl_table_index;
1239 h263_pred_motion(s, 0, 0, &mx, &my);
1240 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1242 s->mv_dir = MV_DIR_FORWARD;
1243 s->mv_type = MV_TYPE_16X16;
1244 s->mv[0][0][0] = mx;
1245 s->mv[0][0][1] = my;
1246 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1248 //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));
1249 s->ac_pred = get_bits1(&s->gb);
1250 *mb_type_ptr = MB_TYPE_INTRA;
1251 if(s->inter_intra_pred){
1252 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1253 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1255 if(s->per_mb_rl_table && cbp){
1256 s->rl_table_index = decode012(&s->gb);
1257 s->rl_chroma_table_index = s->rl_table_index;
1261 s->dsp.clear_blocks(s->block[0]);
1262 for (i = 0; i < 6; i++) {
1263 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1265 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1273 /* init all vlc decoding tables */
1274 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1276 MpegEncContext *s = avctx->priv_data;
1277 static int done = 0;
1281 if (ff_h263_decode_init(avctx) < 0)
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 SKIP_BITS(re, &s->gb, 2);
1801 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1802 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1803 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1804 LAST_SKIP_BITS(re, &s->gb, 1);
1805 #ifdef ERROR_DETAILS
1807 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1808 else if((i>62 && i<192) || i>192+63)
1809 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1814 SKIP_BITS(re, &s->gb, 1);
1815 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1817 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1818 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1819 LAST_SKIP_BITS(re, &s->gb, 1);
1820 #ifdef ERROR_DETAILS
1822 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1823 else if((i>62 && i<192) || i>192+63)
1824 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
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 level=%d\n", level);
1834 else if((i>62 && i<192) || i>192+63)
1835 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1841 const int left= get_bits_left(&s->gb);
1842 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1843 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1846 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1851 block[scan_table[i]] = level;
1855 block[scan_table[i]] = level;
1857 CLOSE_READER(re, &s->gb);
1861 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1863 i = 63; /* XXX: not optimal */
1866 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1867 s->block_last_index[n] = i;
1872 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1873 int *mx_ptr, int *my_ptr)
1878 mv = &mv_tables[s->mv_table_index];
1880 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1882 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1885 if (code == mv->n) {
1886 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1887 mx = get_bits(&s->gb, 6);
1888 my = get_bits(&s->gb, 6);
1890 mx = mv->table_mvx[code];
1891 my = mv->table_mvy[code];
1896 /* WARNING : they do not do exactly modulo encoding */
1911 AVCodec ff_msmpeg4v1_decoder = {
1915 sizeof(MpegEncContext),
1916 ff_msmpeg4_decode_init,
1919 ff_h263_decode_frame,
1920 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1922 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1923 .pix_fmts= ff_pixfmt_list_420,
1926 AVCodec ff_msmpeg4v2_decoder = {
1930 sizeof(MpegEncContext),
1931 ff_msmpeg4_decode_init,
1934 ff_h263_decode_frame,
1935 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1937 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1938 .pix_fmts= ff_pixfmt_list_420,
1941 AVCodec ff_msmpeg4v3_decoder = {
1945 sizeof(MpegEncContext),
1946 ff_msmpeg4_decode_init,
1949 ff_h263_decode_frame,
1950 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1952 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1953 .pix_fmts= ff_pixfmt_list_420,
1956 AVCodec ff_wmv1_decoder = {
1960 sizeof(MpegEncContext),
1961 ff_msmpeg4_decode_init,
1964 ff_h263_decode_frame,
1965 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1967 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1968 .pix_fmts= ff_pixfmt_list_420,