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==AV_PICTURE_TYPE_I){
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==AV_PICTURE_TYPE_P) 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==AV_PICTURE_TYPE_I)
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==AV_PICTURE_TYPE_P);
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 == AV_PICTURE_TYPE_I) {
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);
621 if(s->msmpeg4_version<=2){
622 if (s->pict_type == AV_PICTURE_TYPE_I) {
624 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
626 if (s->use_skip_mb_code)
627 put_bits(&s->pb, 1, 0); /* mb coded */
629 v2_mb_type[(cbp&3) + 4][1],
630 v2_mb_type[(cbp&3) + 4][0]);
632 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
634 ff_h263_cbpy_tab[cbp>>2][1],
635 ff_h263_cbpy_tab[cbp>>2][0]);
637 if (s->pict_type == AV_PICTURE_TYPE_I) {
639 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
641 if (s->use_skip_mb_code)
642 put_bits(&s->pb, 1, 0); /* mb coded */
644 table_mb_non_intra[cbp][1],
645 table_mb_non_intra[cbp][0]);
647 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
648 if(s->inter_intra_pred){
650 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
653 s->misc_bits += get_bits_diff(s);
655 for (i = 0; i < 6; i++) {
656 ff_msmpeg4_encode_block(s, block[i], i);
658 s->i_tex_bits += get_bits_diff(s);
663 #endif //CONFIG_ENCODERS
665 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
666 int32_t **dc_val_ptr)
676 *dc_val_ptr= &s->last_dc[i];
677 return s->last_dc[i];
680 static int get_dc(uint8_t *src, int stride, int scale)
687 sum+=src[x + y*stride];
690 return FASTDIV((sum + (scale>>1)), scale);
693 /* dir = 0: left, dir = 1: top prediction */
694 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
695 int16_t **dc_val_ptr, int *dir_ptr)
697 int a, b, c, wrap, pred, scale;
700 /* find prediction */
702 scale = s->y_dc_scale;
704 scale = s->c_dc_scale;
707 wrap = s->block_wrap[n];
708 dc_val= s->dc_val[0] + s->block_index[n];
714 b = dc_val[ - 1 - wrap];
717 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
721 /* XXX: the following solution consumes divisions, but it does not
722 necessitate to modify mpegvideo.c. The problem comes from the
723 fact they decided to store the quantized DC (which would lead
724 to problems if Q could vary !) */
725 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
727 "movl %3, %%eax \n\t"
728 "shrl $1, %%eax \n\t"
729 "addl %%eax, %2 \n\t"
730 "addl %%eax, %1 \n\t"
731 "addl %0, %%eax \n\t"
733 "movl %%edx, %0 \n\t"
734 "movl %1, %%eax \n\t"
736 "movl %%edx, %1 \n\t"
737 "movl %2, %%eax \n\t"
739 "movl %%edx, %2 \n\t"
740 : "+b" (a), "+c" (b), "+D" (c)
741 : "g" (scale), "S" (ff_inverse[scale])
745 /* #elif ARCH_ALPHA */
746 /* Divisions are extremely costly on Alpha; optimize the most
747 common case. But they are costly everywhere...
750 a = (a + (8 >> 1)) / 8;
751 b = (b + (8 >> 1)) / 8;
752 c = (c + (8 >> 1)) / 8;
754 a = FASTDIV((a + (scale >> 1)), scale);
755 b = FASTDIV((b + (scale >> 1)), scale);
756 c = FASTDIV((c + (scale >> 1)), scale);
759 /* XXX: WARNING: they did not choose the same test as MPEG4. This
760 is very important ! */
761 if(s->msmpeg4_version>3){
762 if(s->inter_intra_pred){
773 if (abs(a - b) < abs(b - c)) {
783 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
786 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
788 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
789 else a= get_dc(dest-8, wrap, scale*8);
790 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
791 else c= get_dc(dest-8*wrap, wrap, scale*8);
793 if (s->h263_aic_dir==0) {
796 }else if (s->h263_aic_dir==1) {
804 }else if (s->h263_aic_dir==2) {
818 if (abs(a - b) < abs(b - c)) {
827 if (abs(a - b) <= abs(b - c)) {
836 /* update predictor */
837 *dc_val_ptr = &dc_val[0];
843 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
849 if(s->msmpeg4_version==1){
851 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
853 /* update predictor */
857 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
859 /* update predictor */
861 *dc_val = level * s->y_dc_scale;
863 *dc_val = level * s->c_dc_scale;
867 /* do the prediction */
870 if(s->msmpeg4_version<=2){
873 v2_dc_lum_table[level+256][1],
874 v2_dc_lum_table[level+256][0]);
877 v2_dc_chroma_table[level+256][1],
878 v2_dc_chroma_table[level+256][0]);
889 else if( s->msmpeg4_version>=6 ) {
890 if( s->qscale == 1 ) {
891 extquant = (level + 3) & 0x3;
892 code = ((level+3)>>2);
893 } else if( s->qscale == 2 ) {
894 extquant = (level + 1) & 0x1;
895 code = ((level+1)>>1);
899 if (s->dc_table_index == 0) {
901 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
903 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
907 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
909 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
913 if(s->msmpeg4_version>=6 && s->qscale<=2)
914 extrabits = 3 - s->qscale;
917 put_bits(&s->pb, 8 + extrabits, level);
918 else if(extrabits > 0)//== VC1 && s->qscale<=2
919 put_bits(&s->pb, extrabits, extquant);
922 put_bits(&s->pb, 1, sign);
927 /* Encoding of a block. Very similar to MPEG4 except for a different
928 escape coding (same as H263) and more vlc tables.
930 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
932 int level, run, last, i, j, last_index;
933 int last_non_zero, sign, slevel;
934 int code, run_diff, dc_pred_dir;
936 const uint8_t *scantable;
939 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
942 rl = &rl_table[s->rl_table_index];
944 rl = &rl_table[3 + s->rl_chroma_table_index];
946 run_diff = s->msmpeg4_version>=4;
947 scantable= s->intra_scantable.permutated;
950 rl = &rl_table[3 + s->rl_table_index];
951 if(s->msmpeg4_version<=2)
955 scantable= s->inter_scantable.permutated;
958 /* recalculate block_last_index for M$ wmv1 */
959 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
960 for(last_index=63; last_index>=0; last_index--){
961 if(block[scantable[last_index]]) break;
963 s->block_last_index[n]= last_index;
965 last_index = s->block_last_index[n];
967 last_non_zero = i - 1;
968 for (; i <= last_index; i++) {
972 run = i - last_non_zero - 1;
973 last = (i == last_index);
981 if(level<=MAX_LEVEL && run<=MAX_RUN){
982 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
985 s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
987 code = get_rl_index(rl, last, run, level);
988 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
992 level1 = level - rl->max_level[last][run];
995 code = get_rl_index(rl, last, run, level1);
998 put_bits(&s->pb, 1, 0);
999 if (level > MAX_LEVEL)
1001 run1 = run - rl->max_run[last][level] - run_diff;
1004 code = get_rl_index(rl, last, run1+1, level);
1005 if (s->msmpeg4_version == 4 && code == rl->n)
1007 code = get_rl_index(rl, last, run1, level);
1008 if (code == rl->n) {
1011 put_bits(&s->pb, 1, 0);
1012 put_bits(&s->pb, 1, last);
1013 if(s->msmpeg4_version>=4){
1014 if(s->esc3_level_length==0){
1015 s->esc3_level_length=8;
1016 s->esc3_run_length= 6;
1017 //ESCLVLSZ + ESCRUNSZ
1019 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1021 put_bits(&s->pb, 8, 3);
1023 put_bits(&s->pb, s->esc3_run_length, run);
1024 put_bits(&s->pb, 1, sign);
1025 put_bits(&s->pb, s->esc3_level_length, level);
1027 put_bits(&s->pb, 6, run);
1028 put_sbits(&s->pb, 8, slevel);
1032 put_bits(&s->pb, 1, 1);
1033 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1034 put_bits(&s->pb, 1, sign);
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);
1043 put_bits(&s->pb, 1, sign);
1050 /****************************************/
1051 /* decoding stuff */
1053 VLC ff_mb_non_intra_vlc[4];
1054 static VLC v2_dc_lum_vlc;
1055 static VLC v2_dc_chroma_vlc;
1056 static VLC v2_intra_cbpc_vlc;
1057 static VLC v2_mb_type_vlc;
1058 static VLC v2_mv_vlc;
1059 VLC ff_inter_intra_vlc;
1061 /* This is identical to h263 except that its range is multiplied by 2. */
1062 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1064 int code, val, sign, shift;
1066 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1067 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1073 sign = get_bits1(&s->gb);
1077 val = (val - 1) << shift;
1078 val |= get_bits(&s->gb, shift);
1093 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1097 if (s->pict_type == AV_PICTURE_TYPE_P) {
1098 if (s->use_skip_mb_code) {
1099 if (get_bits1(&s->gb)) {
1103 s->block_last_index[i] = -1;
1104 s->mv_dir = MV_DIR_FORWARD;
1105 s->mv_type = MV_TYPE_16X16;
1113 if(s->msmpeg4_version==2)
1114 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1116 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1117 if(code<0 || code>7){
1118 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1122 s->mb_intra = code >>2;
1127 if(s->msmpeg4_version==2)
1128 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1130 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1132 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1140 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1142 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1147 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1149 h263_pred_motion(s, 0, 0, &mx, &my);
1150 mx= msmpeg4v2_decode_motion(s, mx, 1);
1151 my= msmpeg4v2_decode_motion(s, my, 1);
1153 s->mv_dir = MV_DIR_FORWARD;
1154 s->mv_type = MV_TYPE_16X16;
1155 s->mv[0][0][0] = mx;
1156 s->mv[0][0][1] = my;
1158 if(s->msmpeg4_version==2){
1159 s->ac_pred = get_bits1(&s->gb);
1160 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1163 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1164 if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
1168 s->dsp.clear_blocks(s->block[0]);
1169 for (i = 0; i < 6; i++) {
1170 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1172 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1179 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1183 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1185 if (s->pict_type == AV_PICTURE_TYPE_P) {
1186 if (s->use_skip_mb_code) {
1187 if (get_bits1(&s->gb)) {
1191 s->block_last_index[i] = -1;
1192 s->mv_dir = MV_DIR_FORWARD;
1193 s->mv_type = MV_TYPE_16X16;
1197 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1203 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1206 //s->mb_intra = (code & 0x40) ? 0 : 1;
1207 s->mb_intra = (~code & 0x40) >> 6;
1212 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1215 /* predict coded block pattern */
1218 int val = ((code >> (5 - i)) & 1);
1220 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1224 cbp |= val << (5 - i);
1230 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1231 if(s->per_mb_rl_table && cbp){
1232 s->rl_table_index = decode012(&s->gb);
1233 s->rl_chroma_table_index = s->rl_table_index;
1235 h263_pred_motion(s, 0, 0, &mx, &my);
1236 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1238 s->mv_dir = MV_DIR_FORWARD;
1239 s->mv_type = MV_TYPE_16X16;
1240 s->mv[0][0][0] = mx;
1241 s->mv[0][0][1] = my;
1242 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1244 //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));
1245 s->ac_pred = get_bits1(&s->gb);
1246 *mb_type_ptr = MB_TYPE_INTRA;
1247 if(s->inter_intra_pred){
1248 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1249 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1251 if(s->per_mb_rl_table && cbp){
1252 s->rl_table_index = decode012(&s->gb);
1253 s->rl_chroma_table_index = s->rl_table_index;
1257 s->dsp.clear_blocks(s->block[0]);
1258 for (i = 0; i < 6; i++) {
1259 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1261 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1269 /* init all vlc decoding tables */
1270 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1272 MpegEncContext *s = avctx->priv_data;
1273 static int done = 0;
1277 if (ff_h263_decode_init(avctx) < 0)
1285 for(i=0;i<NB_RL_TABLES;i++) {
1286 init_rl(&rl_table[i], static_rl_table_store[i]);
1288 INIT_VLC_RL(rl_table[0], 642);
1289 INIT_VLC_RL(rl_table[1], 1104);
1290 INIT_VLC_RL(rl_table[2], 554);
1291 INIT_VLC_RL(rl_table[3], 940);
1292 INIT_VLC_RL(rl_table[4], 962);
1293 INIT_VLC_RL(rl_table[5], 554);
1296 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1297 mv->table_mv_bits, 1, 1,
1298 mv->table_mv_code, 2, 2, 3714);
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, 2694);
1304 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1305 &ff_table0_dc_lum[0][1], 8, 4,
1306 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1307 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1308 &ff_table0_dc_chroma[0][1], 8, 4,
1309 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1310 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1311 &ff_table1_dc_lum[0][1], 8, 4,
1312 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1313 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1314 &ff_table1_dc_chroma[0][1], 8, 4,
1315 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1317 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1318 &v2_dc_lum_table[0][1], 8, 4,
1319 &v2_dc_lum_table[0][0], 8, 4, 1472);
1320 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1321 &v2_dc_chroma_table[0][1], 8, 4,
1322 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1324 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1325 &v2_intra_cbpc[0][1], 2, 1,
1326 &v2_intra_cbpc[0][0], 2, 1, 8);
1327 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1328 &v2_mb_type[0][1], 2, 1,
1329 &v2_mb_type[0][0], 2, 1, 128);
1330 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1332 &mvtab[0][0], 2, 1, 538);
1334 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1335 &wmv2_inter_table[0][0][1], 8, 4,
1336 &wmv2_inter_table[0][0][0], 8, 4, 1636);
1337 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1338 &wmv2_inter_table[1][0][1], 8, 4,
1339 &wmv2_inter_table[1][0][0], 8, 4, 2648);
1340 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1341 &wmv2_inter_table[2][0][1], 8, 4,
1342 &wmv2_inter_table[2][0][0], 8, 4, 1532);
1343 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1344 &wmv2_inter_table[3][0][1], 8, 4,
1345 &wmv2_inter_table[3][0][0], 8, 4, 2488);
1347 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1348 &ff_msmp4_mb_i_table[0][1], 4, 2,
1349 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1351 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1352 &table_inter_intra[0][1], 2, 1,
1353 &table_inter_intra[0][0], 2, 1, 8);
1356 switch(s->msmpeg4_version){
1359 s->decode_mb= msmpeg4v12_decode_mb;
1363 s->decode_mb= msmpeg4v34_decode_mb;
1366 if (CONFIG_WMV2_DECODER)
1367 s->decode_mb= ff_wmv2_decode_mb;
1369 //FIXME + TODO VC1 decode mb
1373 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1378 int msmpeg4_decode_picture_header(MpegEncContext * s)
1382 if(s->msmpeg4_version==1){
1383 int start_code = get_bits_long(&s->gb, 32);
1384 if(start_code!=0x00000100){
1385 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1389 skip_bits(&s->gb, 5); // frame number */
1392 s->pict_type = get_bits(&s->gb, 2) + 1;
1393 if (s->pict_type != AV_PICTURE_TYPE_I &&
1394 s->pict_type != AV_PICTURE_TYPE_P){
1395 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1401 if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
1402 if(!had_i) return -1;
1405 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1407 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1411 if (s->pict_type == AV_PICTURE_TYPE_I) {
1412 code = get_bits(&s->gb, 5);
1413 if(s->msmpeg4_version==1){
1414 if(code==0 || code>s->mb_height){
1415 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1419 s->slice_height = code;
1421 /* 0x17: one slice, 0x18: two slices, ... */
1423 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1427 s->slice_height = s->mb_height / (code - 0x16);
1430 switch(s->msmpeg4_version){
1433 s->rl_chroma_table_index = 2;
1434 s->rl_table_index = 2;
1436 s->dc_table_index = 0; //not used
1439 s->rl_chroma_table_index = decode012(&s->gb);
1440 s->rl_table_index = decode012(&s->gb);
1442 s->dc_table_index = get_bits1(&s->gb);
1445 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1447 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1448 else s->per_mb_rl_table= 0;
1450 if(!s->per_mb_rl_table){
1451 s->rl_chroma_table_index = decode012(&s->gb);
1452 s->rl_table_index = decode012(&s->gb);
1455 s->dc_table_index = get_bits1(&s->gb);
1456 s->inter_intra_pred= 0;
1460 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1461 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1463 s->rl_chroma_table_index,
1469 switch(s->msmpeg4_version){
1472 if(s->msmpeg4_version==1)
1473 s->use_skip_mb_code = 1;
1475 s->use_skip_mb_code = get_bits1(&s->gb);
1476 s->rl_table_index = 2;
1477 s->rl_chroma_table_index = s->rl_table_index;
1478 s->dc_table_index = 0; //not used
1479 s->mv_table_index = 0;
1482 s->use_skip_mb_code = get_bits1(&s->gb);
1483 s->rl_table_index = decode012(&s->gb);
1484 s->rl_chroma_table_index = s->rl_table_index;
1486 s->dc_table_index = get_bits1(&s->gb);
1488 s->mv_table_index = get_bits1(&s->gb);
1491 s->use_skip_mb_code = get_bits1(&s->gb);
1493 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1494 else s->per_mb_rl_table= 0;
1496 if(!s->per_mb_rl_table){
1497 s->rl_table_index = decode012(&s->gb);
1498 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);
1504 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1508 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1509 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1510 s->use_skip_mb_code,
1512 s->rl_chroma_table_index,
1518 if(s->flipflop_rounding){
1519 s->no_rounding ^= 1;
1524 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1526 s->esc3_level_length= 0;
1527 s->esc3_run_length= 0;
1532 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1534 int left= buf_size*8 - get_bits_count(&s->gb);
1535 int length= s->msmpeg4_version>=3 ? 17 : 16;
1536 /* the alt_bitstream reader could read over the end so we need to check it */
1537 if(left>=length && left<length+8)
1541 fps= get_bits(&s->gb, 5);
1542 s->bit_rate= get_bits(&s->gb, 11)*1024;
1543 if(s->msmpeg4_version>=3)
1544 s->flipflop_rounding= get_bits1(&s->gb);
1546 s->flipflop_rounding= 0;
1548 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1550 else if(left<length+8)
1552 s->flipflop_rounding= 0;
1553 if(s->msmpeg4_version != 2)
1554 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1558 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1564 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1568 if(s->msmpeg4_version<=2){
1570 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1572 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1577 }else{ //FIXME optimize use unified tables & index
1579 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1581 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1584 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1588 if (level == DC_MAX) {
1589 level = get_bits(&s->gb, 8);
1590 if (get_bits1(&s->gb))
1592 } else if (level != 0) {
1593 if (get_bits1(&s->gb))
1598 if(s->msmpeg4_version==1){
1600 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1603 /* update predictor */
1607 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1610 /* update predictor */
1612 *dc_val = level * s->y_dc_scale;
1614 *dc_val = level * s->c_dc_scale;
1621 //#define ERROR_DETAILS
1622 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1623 int n, int coded, const uint8_t *scan_table)
1625 int level, i, last, run, run_diff;
1626 int av_uninit(dc_pred_dir);
1628 RL_VLC_ELEM *rl_vlc;
1636 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1639 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1640 if(s->inter_intra_pred) level=0;
1644 rl = &rl_table[s->rl_table_index];
1645 if(level > 256*s->y_dc_scale){
1646 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1647 if(!s->inter_intra_pred) return -1;
1650 rl = &rl_table[3 + s->rl_chroma_table_index];
1651 if(level > 256*s->c_dc_scale){
1652 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1653 if(!s->inter_intra_pred) return -1;
1658 run_diff = s->msmpeg4_version >= 4;
1664 if (dc_pred_dir == 0)
1665 scan_table = s->intra_v_scantable.permutated; /* left */
1667 scan_table = s->intra_h_scantable.permutated; /* top */
1669 scan_table = s->intra_scantable.permutated;
1671 rl_vlc= rl->rl_vlc[0];
1673 qmul = s->qscale << 1;
1674 qadd = (s->qscale - 1) | 1;
1676 rl = &rl_table[3 + s->rl_table_index];
1678 if(s->msmpeg4_version==2)
1684 s->block_last_index[n] = i;
1688 scan_table = s->inter_scantable.permutated;
1689 rl_vlc= rl->rl_vlc[s->qscale];
1692 OPEN_READER(re, &s->gb);
1694 UPDATE_CACHE(re, &s->gb);
1695 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1698 cache= GET_CACHE(re, &s->gb);
1700 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1701 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1703 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1704 UPDATE_CACHE(re, &s->gb);
1705 if(s->msmpeg4_version<=3){
1706 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1707 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1708 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1709 SKIP_COUNTER(re, &s->gb, 1+6+8);
1712 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1713 if(!s->esc3_level_length){
1715 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1717 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1719 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1723 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1725 SKIP_BITS(re, &s->gb, 1);
1727 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1730 s->esc3_level_length= ll;
1731 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1732 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1733 UPDATE_CACHE(re, &s->gb);
1735 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1736 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1738 sign= SHOW_UBITS(re, &s->gb, 1);
1739 SKIP_BITS(re, &s->gb, 1);
1741 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1742 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1743 if(sign) level= -level;
1745 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1746 #if 0 // waste of time / this will detect very few errors
1748 const int abs_level= FFABS(level);
1749 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1750 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1751 if(abs_level <= rl->max_level[last][run]){
1752 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1753 return DECODING_AC_LOST;
1755 if(abs_level <= rl->max_level[last][run]*2){
1756 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1757 return DECODING_AC_LOST;
1759 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1760 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1761 return DECODING_AC_LOST;
1766 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1767 if (level>0) level= level * qmul + qadd;
1768 else level= level * qmul - qadd;
1769 #if 0 // waste of time too :(
1770 if(level>2048 || level<-2048){
1771 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1772 return DECODING_AC_LOST;
1777 #ifdef ERROR_DETAILS
1779 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1780 else if((i>62 && i<192) || i>192+63)
1781 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1785 SKIP_BITS(re, &s->gb, 2);
1786 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1787 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1788 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1789 LAST_SKIP_BITS(re, &s->gb, 1);
1790 #ifdef ERROR_DETAILS
1792 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1793 else if((i>62 && i<192) || i>192+63)
1794 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1799 SKIP_BITS(re, &s->gb, 1);
1800 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1802 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//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 ESC1 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 ESC1 i=%d run=%d level=%d\n", i, run, level);
1814 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1815 LAST_SKIP_BITS(re, &s->gb, 1);
1816 #ifdef ERROR_DETAILS
1818 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1819 else if((i>62 && i<192) || i>192+63)
1820 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1826 const int left= get_bits_left(&s->gb);
1827 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1828 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1831 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1836 block[scan_table[i]] = level;
1840 block[scan_table[i]] = level;
1842 CLOSE_READER(re, &s->gb);
1846 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1848 i = 63; /* XXX: not optimal */
1851 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1852 s->block_last_index[n] = i;
1857 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1858 int *mx_ptr, int *my_ptr)
1863 mv = &mv_tables[s->mv_table_index];
1865 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1867 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1870 if (code == mv->n) {
1871 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1872 mx = get_bits(&s->gb, 6);
1873 my = get_bits(&s->gb, 6);
1875 mx = mv->table_mvx[code];
1876 my = mv->table_mvy[code];
1881 /* WARNING : they do not do exactly modulo encoding */
1896 AVCodec ff_msmpeg4v1_decoder = {
1900 sizeof(MpegEncContext),
1901 ff_msmpeg4_decode_init,
1904 ff_h263_decode_frame,
1905 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1907 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1908 .pix_fmts= ff_pixfmt_list_420,
1911 AVCodec ff_msmpeg4v2_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 2"),
1923 .pix_fmts= ff_pixfmt_list_420,
1926 AVCodec ff_msmpeg4v3_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 3"),
1938 .pix_fmts= ff_pixfmt_list_420,
1941 AVCodec ff_wmv1_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("Windows Media Video 7"),
1953 .pix_fmts= ff_pixfmt_list_420,