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
26 * @file libavcodec/msmpeg4.c
27 * MSMPEG4 backend for ffmpeg encoder and decoder.
32 #include "mpegvideo.h"
34 #include "libavutil/x86_cpu.h"
37 * You can also call this codec : MPEG4 with a twist !
40 * - (encoding) select best mv table (two choices)
41 * - (encoding) select best vlc/dc table
46 #define CBPY_VLC_BITS 6
47 #define V1_INTRA_CBPC_VLC_BITS 6
48 #define V1_INTER_CBPC_VLC_BITS 6
49 #define V2_INTRA_CBPC_VLC_BITS 3
50 #define V2_MB_TYPE_VLC_BITS 7
52 #define V2_MV_VLC_BITS 9
53 #define TEX_VLC_BITS 9
55 #define II_BITRATE 128*1024
56 #define MBAC_BITRATE 50*1024
58 #define DEFAULT_INTER_INDEX 3
60 static uint32_t v2_dc_lum_table[512][2];
61 static uint32_t v2_dc_chroma_table[512][2];
64 extern const uint8_t wmv3_dc_scale_table[32];
70 #include "msmpeg4data.h"
72 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
73 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
74 #endif //CONFIG_ENCODERS
76 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
78 /* This table is practically identical to the one from h263
79 * except that it is inverted. */
80 static av_cold void init_h263_dc_for_msmpeg4(void)
82 int level, uni_code, uni_len;
84 for(level=-256; level<256; level++){
86 /* find number of bits */
95 l= (-level) ^ ((1 << size) - 1);
100 uni_code= DCtab_lum[size][0];
101 uni_len = DCtab_lum[size][1];
102 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
105 uni_code<<=size; uni_code|=l;
108 uni_code<<=1; uni_code|=1;
112 v2_dc_lum_table[level+256][0]= uni_code;
113 v2_dc_lum_table[level+256][1]= uni_len;
115 /* chrominance h263 */
116 uni_code= DCtab_chrom[size][0];
117 uni_len = DCtab_chrom[size][1];
118 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
121 uni_code<<=size; uni_code|=l;
124 uni_code<<=1; uni_code|=1;
128 v2_dc_chroma_table[level+256][0]= uni_code;
129 v2_dc_chroma_table[level+256][1]= uni_len;
134 static av_cold void common_init(MpegEncContext * s)
136 static int initialized=0;
138 switch(s->msmpeg4_version){
142 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
145 if(s->workaround_bugs){
146 s->y_dc_scale_table= old_ff_y_dc_scale_table;
147 s->c_dc_scale_table= wmv1_c_dc_scale_table;
149 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
150 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
155 s->y_dc_scale_table= wmv1_y_dc_scale_table;
156 s->c_dc_scale_table= wmv1_c_dc_scale_table;
158 #if CONFIG_VC1_DECODER
160 s->y_dc_scale_table= wmv3_dc_scale_table;
161 s->c_dc_scale_table= wmv3_dc_scale_table;
168 if(s->msmpeg4_version>=4){
169 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
170 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
171 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
172 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
174 //Note the default tables are set in common_init in mpegvideo.c
179 init_h263_dc_for_msmpeg4();
185 /* build the table which associate a (x,y) motion vector to a vlc */
186 static void init_mv_table(MVTable *tab)
190 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
191 /* mark all entries as not used */
193 tab->table_mv_index[i] = tab->n;
195 for(i=0;i<tab->n;i++) {
196 x = tab->table_mvx[i];
197 y = tab->table_mvy[i];
198 tab->table_mv_index[(x << 6) | y] = i;
202 void ff_msmpeg4_code012(PutBitContext *pb, int n)
208 put_bits(pb, 1, (n >= 2));
212 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
215 int run_diff= intra ? 0 : 1;
217 code = get_rl_index(rl, last, run, level);
218 size+= rl->table_vlc[code][1];
222 level1 = level - rl->max_level[last][run];
225 code = get_rl_index(rl, last, run, level1);
229 if (level > MAX_LEVEL)
231 run1 = run - rl->max_run[last][level] - run_diff;
234 code = get_rl_index(rl, last, run1, level);
241 size+= 1+1+ rl->table_vlc[code][1];
245 size+= 1+1+ rl->table_vlc[code][1];
253 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
255 static int init_done=0;
259 if(s->msmpeg4_version>=4){
265 /* init various encoding tables */
267 init_mv_table(&mv_tables[0]);
268 init_mv_table(&mv_tables[1]);
269 for(i=0;i<NB_RL_TABLES;i++)
270 init_rl(&rl_table[i], static_rl_table_store[i]);
272 for(i=0; i<NB_RL_TABLES; i++){
274 for(level=0; level<=MAX_LEVEL; level++){
276 for(run=0; run<=MAX_RUN; run++){
278 for(last=0; last<2; last++){
279 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
287 static void find_best_tables(MpegEncContext * s)
290 int best =-1, best_size =9999999;
291 int chroma_best=-1, best_chroma_size=9999999;
302 for(level=0; level<=MAX_LEVEL; level++){
304 for(run=0; run<=MAX_RUN; run++){
306 const int last_size= size + chroma_size;
307 for(last=0; last<2; last++){
308 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
309 int intra_luma_count = s->ac_stats[1][0][level][run][last];
310 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
312 if(s->pict_type==FF_I_TYPE){
313 size += intra_luma_count *rl_length[i ][level][run][last];
314 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
316 size+= intra_luma_count *rl_length[i ][level][run][last]
317 +intra_chroma_count*rl_length[i+3][level][run][last]
318 +inter_count *rl_length[i+3][level][run][last];
321 if(last_size == size+chroma_size) break;
328 if(chroma_size<best_chroma_size){
329 best_chroma_size= chroma_size;
334 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
335 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
337 if(s->pict_type==FF_P_TYPE) chroma_best= best;
339 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
341 s->rl_table_index = best;
342 s->rl_chroma_table_index= chroma_best;
344 if(s->pict_type != s->last_non_b_pict_type){
345 s->rl_table_index= 2;
346 if(s->pict_type==FF_I_TYPE)
347 s->rl_chroma_table_index= 1;
349 s->rl_chroma_table_index= 2;
354 /* write MSMPEG4 compatible frame header */
355 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
359 align_put_bits(&s->pb);
360 put_bits(&s->pb, 2, s->pict_type - 1);
362 put_bits(&s->pb, 5, s->qscale);
363 if(s->msmpeg4_version<=2){
364 s->rl_table_index = 2;
365 s->rl_chroma_table_index = 2;
368 s->dc_table_index = 1;
369 s->mv_table_index = 1; /* only if P frame */
370 s->use_skip_mb_code = 1; /* only if P frame */
371 s->per_mb_rl_table = 0;
372 if(s->msmpeg4_version==4)
373 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
374 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
376 if (s->pict_type == FF_I_TYPE) {
377 s->slice_height= s->mb_height/1;
378 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
380 if(s->msmpeg4_version==4){
381 msmpeg4_encode_ext_header(s);
382 if(s->bit_rate>MBAC_BITRATE)
383 put_bits(&s->pb, 1, s->per_mb_rl_table);
386 if(s->msmpeg4_version>2){
387 if(!s->per_mb_rl_table){
388 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
389 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
392 put_bits(&s->pb, 1, s->dc_table_index);
395 put_bits(&s->pb, 1, s->use_skip_mb_code);
397 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
398 put_bits(&s->pb, 1, s->per_mb_rl_table);
400 if(s->msmpeg4_version>2){
401 if(!s->per_mb_rl_table)
402 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
404 put_bits(&s->pb, 1, s->dc_table_index);
406 put_bits(&s->pb, 1, s->mv_table_index);
410 s->esc3_level_length= 0;
411 s->esc3_run_length= 0;
414 void msmpeg4_encode_ext_header(MpegEncContext * s)
416 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
418 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
420 if(s->msmpeg4_version>=3)
421 put_bits(&s->pb, 1, s->flipflop_rounding);
423 assert(s->flipflop_rounding==0);
426 #endif //CONFIG_ENCODERS
428 /* predict coded block */
429 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
431 int xy, wrap, pred, a, b, c;
433 xy = s->block_index[n];
439 a = s->coded_block[xy - 1 ];
440 b = s->coded_block[xy - 1 - wrap];
441 c = s->coded_block[xy - wrap];
450 *coded_block_ptr = &s->coded_block[xy];
457 void ff_msmpeg4_encode_motion(MpegEncContext * s,
463 /* modulo encoding */
464 /* WARNING : you cannot reach all the MVs even with the modulo
465 encoding. This is a somewhat strange compromise they took !!! */
478 if ((unsigned)mx >= 64 ||
480 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
482 mv = &mv_tables[s->mv_table_index];
484 code = mv->table_mv_index[(mx << 6) | my];
486 mv->table_mv_bits[code],
487 mv->table_mv_code[code]);
489 /* escape : code literally */
490 put_bits(&s->pb, 6, mx);
491 put_bits(&s->pb, 6, my);
495 void ff_msmpeg4_handle_slices(MpegEncContext *s){
497 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
498 if(s->msmpeg4_version < 4){
499 ff_mpeg4_clean_buffers(s);
501 s->first_slice_line = 1;
503 s->first_slice_line = 0;
508 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
510 int range, bit_size, sign, code, bits;
515 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
517 bit_size = s->f_code - 1;
518 range = 1 << bit_size;
531 code = (val >> bit_size) + 1;
532 bits = val & (range - 1);
534 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
536 put_bits(&s->pb, bit_size, bits);
541 void msmpeg4_encode_mb(MpegEncContext * s,
542 DCTELEM block[6][64],
543 int motion_x, int motion_y)
545 int cbp, coded_cbp, i;
547 uint8_t *coded_block;
549 ff_msmpeg4_handle_slices(s);
554 for (i = 0; i < 6; i++) {
555 if (s->block_last_index[i] >= 0)
558 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
559 /* skip macroblock */
560 put_bits(&s->pb, 1, 1);
567 if (s->use_skip_mb_code)
568 put_bits(&s->pb, 1, 0); /* mb coded */
570 if(s->msmpeg4_version<=2){
572 v2_mb_type[cbp&3][1],
573 v2_mb_type[cbp&3][0]);
574 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
578 cbpy_tab[coded_cbp>>2][1],
579 cbpy_tab[coded_cbp>>2][0]);
581 s->misc_bits += get_bits_diff(s);
583 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
584 msmpeg4v2_encode_motion(s, motion_x - pred_x);
585 msmpeg4v2_encode_motion(s, motion_y - pred_y);
588 table_mb_non_intra[cbp + 64][1],
589 table_mb_non_intra[cbp + 64][0]);
591 s->misc_bits += get_bits_diff(s);
594 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
595 ff_msmpeg4_encode_motion(s, motion_x - pred_x,
599 s->mv_bits += get_bits_diff(s);
601 for (i = 0; i < 6; i++) {
602 ff_msmpeg4_encode_block(s, block[i], i);
604 s->p_tex_bits += get_bits_diff(s);
609 for (i = 0; i < 6; i++) {
611 val = (s->block_last_index[i] >= 1);
612 cbp |= val << (5 - i);
614 /* predict value for close blocks only for luma */
615 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
619 coded_cbp |= val << (5 - i);
623 printf("cbp=%x %x\n", cbp, coded_cbp);
626 if(s->msmpeg4_version<=2){
627 if (s->pict_type == FF_I_TYPE) {
629 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
631 if (s->use_skip_mb_code)
632 put_bits(&s->pb, 1, 0); /* mb coded */
634 v2_mb_type[(cbp&3) + 4][1],
635 v2_mb_type[(cbp&3) + 4][0]);
637 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
640 cbpy_tab[cbp>>2][0]);
642 if (s->pict_type == FF_I_TYPE) {
644 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
646 if (s->use_skip_mb_code)
647 put_bits(&s->pb, 1, 0); /* mb coded */
649 table_mb_non_intra[cbp][1],
650 table_mb_non_intra[cbp][0]);
652 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
653 if(s->inter_intra_pred){
655 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
658 s->misc_bits += get_bits_diff(s);
660 for (i = 0; i < 6; i++) {
661 ff_msmpeg4_encode_block(s, block[i], i);
663 s->i_tex_bits += get_bits_diff(s);
668 #endif //CONFIG_ENCODERS
670 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
671 int32_t **dc_val_ptr)
681 *dc_val_ptr= &s->last_dc[i];
682 return s->last_dc[i];
685 static int get_dc(uint8_t *src, int stride, int scale)
692 sum+=src[x + y*stride];
695 return FASTDIV((sum + (scale>>1)), scale);
698 /* dir = 0: left, dir = 1: top prediction */
699 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
700 int16_t **dc_val_ptr, int *dir_ptr)
702 int a, b, c, wrap, pred, scale;
705 /* find prediction */
707 scale = s->y_dc_scale;
709 scale = s->c_dc_scale;
712 wrap = s->block_wrap[n];
713 dc_val= s->dc_val[0] + s->block_index[n];
719 b = dc_val[ - 1 - wrap];
722 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
726 /* XXX: the following solution consumes divisions, but it does not
727 necessitate to modify mpegvideo.c. The problem comes from the
728 fact they decided to store the quantized DC (which would lead
729 to problems if Q could vary !) */
730 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
732 "movl %3, %%eax \n\t"
733 "shrl $1, %%eax \n\t"
734 "addl %%eax, %2 \n\t"
735 "addl %%eax, %1 \n\t"
736 "addl %0, %%eax \n\t"
738 "movl %%edx, %0 \n\t"
739 "movl %1, %%eax \n\t"
741 "movl %%edx, %1 \n\t"
742 "movl %2, %%eax \n\t"
744 "movl %%edx, %2 \n\t"
745 : "+b" (a), "+c" (b), "+D" (c)
746 : "g" (scale), "S" (ff_inverse[scale])
750 /* #elif ARCH_ALPHA */
751 /* Divisions are extremely costly on Alpha; optimize the most
752 common case. But they are costly everywhere...
755 a = (a + (8 >> 1)) / 8;
756 b = (b + (8 >> 1)) / 8;
757 c = (c + (8 >> 1)) / 8;
759 a = FASTDIV((a + (scale >> 1)), scale);
760 b = FASTDIV((b + (scale >> 1)), scale);
761 c = FASTDIV((c + (scale >> 1)), scale);
764 /* XXX: WARNING: they did not choose the same test as MPEG4. This
765 is very important ! */
766 if(s->msmpeg4_version>3){
767 if(s->inter_intra_pred){
778 if (abs(a - b) < abs(b - c)) {
788 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
791 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
793 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
794 else a= get_dc(dest-8, wrap, scale*8);
795 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
796 else c= get_dc(dest-8*wrap, wrap, scale*8);
798 if (s->h263_aic_dir==0) {
801 }else if (s->h263_aic_dir==1) {
809 }else if (s->h263_aic_dir==2) {
823 if (abs(a - b) < abs(b - c)) {
832 if (abs(a - b) <= abs(b - c)) {
841 /* update predictor */
842 *dc_val_ptr = &dc_val[0];
848 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
854 if(s->msmpeg4_version==1){
856 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
858 /* update predictor */
862 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
864 /* update predictor */
866 *dc_val = level * s->y_dc_scale;
868 *dc_val = level * s->c_dc_scale;
872 /* do the prediction */
875 if(s->msmpeg4_version<=2){
878 v2_dc_lum_table[level+256][1],
879 v2_dc_lum_table[level+256][0]);
882 v2_dc_chroma_table[level+256][1],
883 v2_dc_chroma_table[level+256][0]);
894 else if( s->msmpeg4_version>=6 ) {
895 if( s->qscale == 1 ) {
896 extquant = (level + 3) & 0x3;
897 code = ((level+3)>>2);
898 } else if( s->qscale == 2 ) {
899 extquant = (level + 1) & 0x1;
900 code = ((level+1)>>1);
904 if (s->dc_table_index == 0) {
906 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
908 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
912 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
914 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
918 if(s->msmpeg4_version>=6 && s->qscale<=2)
919 extrabits = 3 - s->qscale;
922 put_bits(&s->pb, 8 + extrabits, level);
923 else if(extrabits > 0)//== VC1 && s->qscale<=2
924 put_bits(&s->pb, extrabits, extquant);
927 put_bits(&s->pb, 1, sign);
932 /* Encoding of a block. Very similar to MPEG4 except for a different
933 escape coding (same as H263) and more vlc tables.
935 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
937 int level, run, last, i, j, last_index;
938 int last_non_zero, sign, slevel;
939 int code, run_diff, dc_pred_dir;
941 const uint8_t *scantable;
944 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
947 rl = &rl_table[s->rl_table_index];
949 rl = &rl_table[3 + s->rl_chroma_table_index];
951 run_diff = s->msmpeg4_version>=4;
952 scantable= s->intra_scantable.permutated;
955 rl = &rl_table[3 + s->rl_table_index];
956 if(s->msmpeg4_version<=2)
960 scantable= s->inter_scantable.permutated;
963 /* recalculate block_last_index for M$ wmv1 */
964 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
965 for(last_index=63; last_index>=0; last_index--){
966 if(block[scantable[last_index]]) break;
968 s->block_last_index[n]= last_index;
970 last_index = s->block_last_index[n];
972 last_non_zero = i - 1;
973 for (; i <= last_index; i++) {
977 run = i - last_non_zero - 1;
978 last = (i == last_index);
986 if(level<=MAX_LEVEL && run<=MAX_RUN){
987 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
991 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
993 code = get_rl_index(rl, last, run, level);
994 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
998 level1 = level - rl->max_level[last][run];
1001 code = get_rl_index(rl, last, run, level1);
1002 if (code == rl->n) {
1004 put_bits(&s->pb, 1, 0);
1005 if (level > MAX_LEVEL)
1007 run1 = run - rl->max_run[last][level] - run_diff;
1010 code = get_rl_index(rl, last, run1+1, level);
1011 if (s->msmpeg4_version == 4 && code == rl->n)
1013 code = get_rl_index(rl, last, run1, level);
1014 if (code == rl->n) {
1017 put_bits(&s->pb, 1, 0);
1018 put_bits(&s->pb, 1, last);
1019 if(s->msmpeg4_version>=4){
1020 if(s->esc3_level_length==0){
1021 s->esc3_level_length=8;
1022 s->esc3_run_length= 6;
1023 //ESCLVLSZ + ESCRUNSZ
1025 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1027 put_bits(&s->pb, 8, 3);
1029 put_bits(&s->pb, s->esc3_run_length, run);
1030 put_bits(&s->pb, 1, sign);
1031 put_bits(&s->pb, s->esc3_level_length, level);
1033 put_bits(&s->pb, 6, run);
1034 put_sbits(&s->pb, 8, slevel);
1038 put_bits(&s->pb, 1, 1);
1039 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1040 put_bits(&s->pb, 1, sign);
1044 put_bits(&s->pb, 1, 1);
1045 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1046 put_bits(&s->pb, 1, sign);
1049 put_bits(&s->pb, 1, sign);
1056 /****************************************/
1057 /* decoding stuff */
1059 VLC ff_mb_non_intra_vlc[4];
1060 static VLC v2_dc_lum_vlc;
1061 static VLC v2_dc_chroma_vlc;
1062 static VLC cbpy_vlc;
1063 static VLC v2_intra_cbpc_vlc;
1064 static VLC v2_mb_type_vlc;
1065 static VLC v2_mv_vlc;
1066 static VLC v1_intra_cbpc_vlc;
1067 static VLC v1_inter_cbpc_vlc;
1068 VLC ff_inter_intra_vlc;
1070 /* This is identical to h263 except that its range is multiplied by 2. */
1071 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1073 int code, val, sign, shift;
1075 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1076 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1082 sign = get_bits1(&s->gb);
1086 val = (val - 1) << shift;
1087 val |= get_bits(&s->gb, shift);
1102 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1106 if (s->pict_type == FF_P_TYPE) {
1107 if (s->use_skip_mb_code) {
1108 if (get_bits1(&s->gb)) {
1112 s->block_last_index[i] = -1;
1113 s->mv_dir = MV_DIR_FORWARD;
1114 s->mv_type = MV_TYPE_16X16;
1122 if(s->msmpeg4_version==2)
1123 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1125 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1126 if(code<0 || code>7){
1127 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1131 s->mb_intra = code >>2;
1136 if(s->msmpeg4_version==2)
1137 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1139 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1141 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1149 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1151 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1156 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1158 h263_pred_motion(s, 0, 0, &mx, &my);
1159 mx= msmpeg4v2_decode_motion(s, mx, 1);
1160 my= msmpeg4v2_decode_motion(s, my, 1);
1162 s->mv_dir = MV_DIR_FORWARD;
1163 s->mv_type = MV_TYPE_16X16;
1164 s->mv[0][0][0] = mx;
1165 s->mv[0][0][1] = my;
1167 if(s->msmpeg4_version==2){
1168 s->ac_pred = get_bits1(&s->gb);
1169 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1172 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1173 if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1177 s->dsp.clear_blocks(s->block[0]);
1178 for (i = 0; i < 6; i++) {
1179 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1181 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1188 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1192 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1194 if (s->pict_type == FF_P_TYPE) {
1195 if (s->use_skip_mb_code) {
1196 if (get_bits1(&s->gb)) {
1200 s->block_last_index[i] = -1;
1201 s->mv_dir = MV_DIR_FORWARD;
1202 s->mv_type = MV_TYPE_16X16;
1206 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1212 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1215 //s->mb_intra = (code & 0x40) ? 0 : 1;
1216 s->mb_intra = (~code & 0x40) >> 6;
1221 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1224 /* predict coded block pattern */
1227 int val = ((code >> (5 - i)) & 1);
1229 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1233 cbp |= val << (5 - i);
1239 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1240 if(s->per_mb_rl_table && cbp){
1241 s->rl_table_index = decode012(&s->gb);
1242 s->rl_chroma_table_index = s->rl_table_index;
1244 h263_pred_motion(s, 0, 0, &mx, &my);
1245 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1247 s->mv_dir = MV_DIR_FORWARD;
1248 s->mv_type = MV_TYPE_16X16;
1249 s->mv[0][0][0] = mx;
1250 s->mv[0][0][1] = my;
1251 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1253 //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));
1254 s->ac_pred = get_bits1(&s->gb);
1255 *mb_type_ptr = MB_TYPE_INTRA;
1256 if(s->inter_intra_pred){
1257 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1258 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1260 if(s->per_mb_rl_table && cbp){
1261 s->rl_table_index = decode012(&s->gb);
1262 s->rl_chroma_table_index = s->rl_table_index;
1266 s->dsp.clear_blocks(s->block[0]);
1267 for (i = 0; i < 6; i++) {
1268 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1270 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1278 /* init all vlc decoding tables */
1279 av_cold int ff_msmpeg4_decode_init(MpegEncContext *s)
1281 static int done = 0;
1290 for(i=0;i<NB_RL_TABLES;i++) {
1291 init_rl(&rl_table[i], static_rl_table_store[i]);
1293 INIT_VLC_RL(rl_table[0], 642);
1294 INIT_VLC_RL(rl_table[1], 1104);
1295 INIT_VLC_RL(rl_table[2], 554);
1296 INIT_VLC_RL(rl_table[3], 940);
1297 INIT_VLC_RL(rl_table[4], 962);
1298 INIT_VLC_RL(rl_table[5], 554);
1301 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1302 mv->table_mv_bits, 1, 1,
1303 mv->table_mv_code, 2, 2, 3714);
1305 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1306 mv->table_mv_bits, 1, 1,
1307 mv->table_mv_code, 2, 2, 2694);
1309 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1310 &ff_table0_dc_lum[0][1], 8, 4,
1311 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1312 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1313 &ff_table0_dc_chroma[0][1], 8, 4,
1314 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1315 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1316 &ff_table1_dc_lum[0][1], 8, 4,
1317 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1318 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1319 &ff_table1_dc_chroma[0][1], 8, 4,
1320 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1322 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1323 &v2_dc_lum_table[0][1], 8, 4,
1324 &v2_dc_lum_table[0][0], 8, 4, 1472);
1325 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1326 &v2_dc_chroma_table[0][1], 8, 4,
1327 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1329 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
1330 &cbpy_tab[0][1], 2, 1,
1331 &cbpy_tab[0][0], 2, 1, 64);
1332 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1333 &v2_intra_cbpc[0][1], 2, 1,
1334 &v2_intra_cbpc[0][0], 2, 1, 8);
1335 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1336 &v2_mb_type[0][1], 2, 1,
1337 &v2_mb_type[0][0], 2, 1, 128);
1338 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1340 &mvtab[0][0], 2, 1, 538);
1342 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1343 &wmv2_inter_table[0][0][1], 8, 4,
1344 &wmv2_inter_table[0][0][0], 8, 4, 1636);
1345 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1346 &wmv2_inter_table[1][0][1], 8, 4,
1347 &wmv2_inter_table[1][0][0], 8, 4, 2648);
1348 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1349 &wmv2_inter_table[2][0][1], 8, 4,
1350 &wmv2_inter_table[2][0][0], 8, 4, 1532);
1351 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1352 &wmv2_inter_table[3][0][1], 8, 4,
1353 &wmv2_inter_table[3][0][0], 8, 4, 2488);
1355 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1356 &ff_msmp4_mb_i_table[0][1], 4, 2,
1357 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1359 INIT_VLC_STATIC(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1360 intra_MCBPC_bits, 1, 1,
1361 intra_MCBPC_code, 1, 1, 64);
1362 INIT_VLC_STATIC(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1363 inter_MCBPC_bits, 1, 1,
1364 inter_MCBPC_code, 1, 1, 104);
1366 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1367 &table_inter_intra[0][1], 2, 1,
1368 &table_inter_intra[0][0], 2, 1, 8);
1371 switch(s->msmpeg4_version){
1374 s->decode_mb= msmpeg4v12_decode_mb;
1378 s->decode_mb= msmpeg4v34_decode_mb;
1381 if (CONFIG_WMV2_DECODER)
1382 s->decode_mb= ff_wmv2_decode_mb;
1384 //FIXME + TODO VC1 decode mb
1388 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1393 int msmpeg4_decode_picture_header(MpegEncContext * s)
1400 for(i=0; i<s->gb.size_in_bits; i++)
1401 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1402 // get_bits1(&s->gb);
1403 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1408 if(s->msmpeg4_version==1){
1410 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1411 if(start_code!=0x00000100){
1412 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1416 skip_bits(&s->gb, 5); // frame number */
1419 s->pict_type = get_bits(&s->gb, 2) + 1;
1420 if (s->pict_type != FF_I_TYPE &&
1421 s->pict_type != FF_P_TYPE){
1422 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1428 if(s->pict_type == FF_I_TYPE) had_i=1;
1429 if(!had_i) return -1;
1432 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1434 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1438 if (s->pict_type == FF_I_TYPE) {
1439 code = get_bits(&s->gb, 5);
1440 if(s->msmpeg4_version==1){
1441 if(code==0 || code>s->mb_height){
1442 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1446 s->slice_height = code;
1448 /* 0x17: one slice, 0x18: two slices, ... */
1450 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1454 s->slice_height = s->mb_height / (code - 0x16);
1457 switch(s->msmpeg4_version){
1460 s->rl_chroma_table_index = 2;
1461 s->rl_table_index = 2;
1463 s->dc_table_index = 0; //not used
1466 s->rl_chroma_table_index = decode012(&s->gb);
1467 s->rl_table_index = decode012(&s->gb);
1469 s->dc_table_index = get_bits1(&s->gb);
1472 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1474 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1475 else s->per_mb_rl_table= 0;
1477 if(!s->per_mb_rl_table){
1478 s->rl_chroma_table_index = decode012(&s->gb);
1479 s->rl_table_index = decode012(&s->gb);
1482 s->dc_table_index = get_bits1(&s->gb);
1483 s->inter_intra_pred= 0;
1487 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1488 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1490 s->rl_chroma_table_index,
1496 switch(s->msmpeg4_version){
1499 if(s->msmpeg4_version==1)
1500 s->use_skip_mb_code = 1;
1502 s->use_skip_mb_code = get_bits1(&s->gb);
1503 s->rl_table_index = 2;
1504 s->rl_chroma_table_index = s->rl_table_index;
1505 s->dc_table_index = 0; //not used
1506 s->mv_table_index = 0;
1509 s->use_skip_mb_code = get_bits1(&s->gb);
1510 s->rl_table_index = decode012(&s->gb);
1511 s->rl_chroma_table_index = s->rl_table_index;
1513 s->dc_table_index = get_bits1(&s->gb);
1515 s->mv_table_index = get_bits1(&s->gb);
1518 s->use_skip_mb_code = get_bits1(&s->gb);
1520 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1521 else s->per_mb_rl_table= 0;
1523 if(!s->per_mb_rl_table){
1524 s->rl_table_index = decode012(&s->gb);
1525 s->rl_chroma_table_index = s->rl_table_index;
1528 s->dc_table_index = get_bits1(&s->gb);
1530 s->mv_table_index = get_bits1(&s->gb);
1531 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1535 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1536 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1537 s->use_skip_mb_code,
1539 s->rl_chroma_table_index,
1545 if(s->flipflop_rounding){
1546 s->no_rounding ^= 1;
1551 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1553 s->esc3_level_length= 0;
1554 s->esc3_run_length= 0;
1559 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1561 int left= buf_size*8 - get_bits_count(&s->gb);
1562 int length= s->msmpeg4_version>=3 ? 17 : 16;
1563 /* the alt_bitstream reader could read over the end so we need to check it */
1564 if(left>=length && left<length+8)
1568 fps= get_bits(&s->gb, 5);
1569 s->bit_rate= get_bits(&s->gb, 11)*1024;
1570 if(s->msmpeg4_version>=3)
1571 s->flipflop_rounding= get_bits1(&s->gb);
1573 s->flipflop_rounding= 0;
1575 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1577 else if(left<length+8)
1579 s->flipflop_rounding= 0;
1580 if(s->msmpeg4_version != 2)
1581 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1585 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1591 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1595 if(s->msmpeg4_version<=2){
1597 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1599 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1604 }else{ //FIXME optimize use unified tables & index
1606 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1608 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1611 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1615 if (level == DC_MAX) {
1616 level = get_bits(&s->gb, 8);
1617 if (get_bits1(&s->gb))
1619 } else if (level != 0) {
1620 if (get_bits1(&s->gb))
1625 if(s->msmpeg4_version==1){
1627 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1630 /* update predictor */
1634 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1637 /* update predictor */
1639 *dc_val = level * s->y_dc_scale;
1641 *dc_val = level * s->c_dc_scale;
1648 //#define ERROR_DETAILS
1649 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1650 int n, int coded, const uint8_t *scan_table)
1652 int level, i, last, run, run_diff;
1653 int av_uninit(dc_pred_dir);
1655 RL_VLC_ELEM *rl_vlc;
1663 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1666 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1667 if(s->inter_intra_pred) level=0;
1671 rl = &rl_table[s->rl_table_index];
1672 if(level > 256*s->y_dc_scale){
1673 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1674 if(!s->inter_intra_pred) return -1;
1677 rl = &rl_table[3 + s->rl_chroma_table_index];
1678 if(level > 256*s->c_dc_scale){
1679 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1680 if(!s->inter_intra_pred) return -1;
1685 run_diff = s->msmpeg4_version >= 4;
1691 if (dc_pred_dir == 0)
1692 scan_table = s->intra_v_scantable.permutated; /* left */
1694 scan_table = s->intra_h_scantable.permutated; /* top */
1696 scan_table = s->intra_scantable.permutated;
1698 rl_vlc= rl->rl_vlc[0];
1700 qmul = s->qscale << 1;
1701 qadd = (s->qscale - 1) | 1;
1703 rl = &rl_table[3 + s->rl_table_index];
1705 if(s->msmpeg4_version==2)
1711 s->block_last_index[n] = i;
1715 scan_table = s->inter_scantable.permutated;
1716 rl_vlc= rl->rl_vlc[s->qscale];
1719 OPEN_READER(re, &s->gb);
1721 UPDATE_CACHE(re, &s->gb);
1722 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1725 cache= GET_CACHE(re, &s->gb);
1727 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1728 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1730 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1731 UPDATE_CACHE(re, &s->gb);
1732 if(s->msmpeg4_version<=3){
1733 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1734 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1735 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1736 SKIP_COUNTER(re, &s->gb, 1+6+8);
1739 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1740 if(!s->esc3_level_length){
1742 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1744 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1746 if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1747 SKIP_BITS(re, &s->gb, 1);
1752 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1754 SKIP_BITS(re, &s->gb, 1);
1756 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1759 s->esc3_level_length= ll;
1760 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1761 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1762 UPDATE_CACHE(re, &s->gb);
1764 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1765 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1767 sign= SHOW_UBITS(re, &s->gb, 1);
1768 SKIP_BITS(re, &s->gb, 1);
1770 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1771 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1772 if(sign) level= -level;
1774 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1775 #if 0 // waste of time / this will detect very few errors
1777 const int abs_level= FFABS(level);
1778 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1779 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1780 if(abs_level <= rl->max_level[last][run]){
1781 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1782 return DECODING_AC_LOST;
1784 if(abs_level <= rl->max_level[last][run]*2){
1785 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1786 return DECODING_AC_LOST;
1788 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1789 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1790 return DECODING_AC_LOST;
1795 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1796 if (level>0) level= level * qmul + qadd;
1797 else level= level * qmul - qadd;
1798 #if 0 // waste of time too :(
1799 if(level>2048 || level<-2048){
1800 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1801 return DECODING_AC_LOST;
1806 #ifdef ERROR_DETAILS
1808 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1809 else if((i>62 && i<192) || i>192+63)
1810 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1814 #if MIN_CACHE_BITS < 23
1815 LAST_SKIP_BITS(re, &s->gb, 2);
1816 UPDATE_CACHE(re, &s->gb);
1818 SKIP_BITS(re, &s->gb, 2);
1820 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1821 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1822 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1823 LAST_SKIP_BITS(re, &s->gb, 1);
1824 #ifdef ERROR_DETAILS
1826 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1827 else if((i>62 && i<192) || i>192+63)
1828 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1833 #if MIN_CACHE_BITS < 22
1834 LAST_SKIP_BITS(re, &s->gb, 1);
1835 UPDATE_CACHE(re, &s->gb);
1837 SKIP_BITS(re, &s->gb, 1);
1839 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1841 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1842 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1843 LAST_SKIP_BITS(re, &s->gb, 1);
1844 #ifdef ERROR_DETAILS
1846 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1847 else if((i>62 && i<192) || i>192+63)
1848 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1853 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1854 LAST_SKIP_BITS(re, &s->gb, 1);
1855 #ifdef ERROR_DETAILS
1857 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1858 else if((i>62 && i<192) || i>192+63)
1859 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1865 const int left= get_bits_left(&s->gb);
1866 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1867 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1870 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1875 block[scan_table[i]] = level;
1879 block[scan_table[i]] = level;
1881 CLOSE_READER(re, &s->gb);
1885 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1887 i = 63; /* XXX: not optimal */
1890 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1891 s->block_last_index[n] = i;
1896 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1897 int *mx_ptr, int *my_ptr)
1902 mv = &mv_tables[s->mv_table_index];
1904 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1906 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1909 if (code == mv->n) {
1910 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1911 mx = get_bits(&s->gb, 6);
1912 my = get_bits(&s->gb, 6);
1914 mx = mv->table_mvx[code];
1915 my = mv->table_mvy[code];
1920 /* WARNING : they do not do exactly modulo encoding */