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.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
786 dest= s->current_picture.f.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)
850 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
852 /* update predictor */
854 *dc_val = level * s->y_dc_scale;
856 *dc_val = level * s->c_dc_scale;
859 /* do the prediction */
862 if(s->msmpeg4_version<=2){
865 v2_dc_lum_table[level+256][1],
866 v2_dc_lum_table[level+256][0]);
869 v2_dc_chroma_table[level+256][1],
870 v2_dc_chroma_table[level+256][0]);
881 else if( s->msmpeg4_version>=6 ) {
882 if( s->qscale == 1 ) {
883 extquant = (level + 3) & 0x3;
884 code = ((level+3)>>2);
885 } else if( s->qscale == 2 ) {
886 extquant = (level + 1) & 0x1;
887 code = ((level+1)>>1);
891 if (s->dc_table_index == 0) {
893 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
895 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
899 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
901 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
905 if(s->msmpeg4_version>=6 && s->qscale<=2)
906 extrabits = 3 - s->qscale;
909 put_bits(&s->pb, 8 + extrabits, level);
910 else if(extrabits > 0)//== VC1 && s->qscale<=2
911 put_bits(&s->pb, extrabits, extquant);
914 put_bits(&s->pb, 1, sign);
919 /* Encoding of a block. Very similar to MPEG4 except for a different
920 escape coding (same as H263) and more vlc tables.
922 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
924 int level, run, last, i, j, last_index;
925 int last_non_zero, sign, slevel;
926 int code, run_diff, dc_pred_dir;
928 const uint8_t *scantable;
931 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
934 rl = &rl_table[s->rl_table_index];
936 rl = &rl_table[3 + s->rl_chroma_table_index];
938 run_diff = s->msmpeg4_version>=4;
939 scantable= s->intra_scantable.permutated;
942 rl = &rl_table[3 + s->rl_table_index];
943 if(s->msmpeg4_version<=2)
947 scantable= s->inter_scantable.permutated;
950 /* recalculate block_last_index for M$ wmv1 */
951 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
952 for(last_index=63; last_index>=0; last_index--){
953 if(block[scantable[last_index]]) break;
955 s->block_last_index[n]= last_index;
957 last_index = s->block_last_index[n];
959 last_non_zero = i - 1;
960 for (; i <= last_index; i++) {
964 run = i - last_non_zero - 1;
965 last = (i == last_index);
973 if(level<=MAX_LEVEL && run<=MAX_RUN){
974 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
977 s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
979 code = get_rl_index(rl, last, run, level);
980 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
984 level1 = level - rl->max_level[last][run];
987 code = get_rl_index(rl, last, run, level1);
990 put_bits(&s->pb, 1, 0);
991 if (level > MAX_LEVEL)
993 run1 = run - rl->max_run[last][level] - run_diff;
996 code = get_rl_index(rl, last, run1+1, level);
997 if (s->msmpeg4_version == 4 && code == rl->n)
999 code = get_rl_index(rl, last, run1, level);
1000 if (code == rl->n) {
1003 put_bits(&s->pb, 1, 0);
1004 put_bits(&s->pb, 1, last);
1005 if(s->msmpeg4_version>=4){
1006 if(s->esc3_level_length==0){
1007 s->esc3_level_length=8;
1008 s->esc3_run_length= 6;
1009 //ESCLVLSZ + ESCRUNSZ
1011 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1013 put_bits(&s->pb, 8, 3);
1015 put_bits(&s->pb, s->esc3_run_length, run);
1016 put_bits(&s->pb, 1, sign);
1017 put_bits(&s->pb, s->esc3_level_length, level);
1019 put_bits(&s->pb, 6, run);
1020 put_sbits(&s->pb, 8, slevel);
1024 put_bits(&s->pb, 1, 1);
1025 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1026 put_bits(&s->pb, 1, sign);
1030 put_bits(&s->pb, 1, 1);
1031 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1032 put_bits(&s->pb, 1, sign);
1035 put_bits(&s->pb, 1, sign);
1042 /****************************************/
1043 /* decoding stuff */
1045 VLC ff_mb_non_intra_vlc[4];
1046 static VLC v2_dc_lum_vlc;
1047 static VLC v2_dc_chroma_vlc;
1048 static VLC v2_intra_cbpc_vlc;
1049 static VLC v2_mb_type_vlc;
1050 static VLC v2_mv_vlc;
1051 VLC ff_inter_intra_vlc;
1053 /* This is identical to h263 except that its range is multiplied by 2. */
1054 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1056 int code, val, sign, shift;
1058 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1059 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1065 sign = get_bits1(&s->gb);
1069 val = (val - 1) << shift;
1070 val |= get_bits(&s->gb, shift);
1085 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1089 if (s->pict_type == AV_PICTURE_TYPE_P) {
1090 if (s->use_skip_mb_code) {
1091 if (get_bits1(&s->gb)) {
1095 s->block_last_index[i] = -1;
1096 s->mv_dir = MV_DIR_FORWARD;
1097 s->mv_type = MV_TYPE_16X16;
1105 if(s->msmpeg4_version==2)
1106 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1108 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1109 if(code<0 || code>7){
1110 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1114 s->mb_intra = code >>2;
1119 if(s->msmpeg4_version==2)
1120 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1122 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1124 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1132 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1134 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1139 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1141 h263_pred_motion(s, 0, 0, &mx, &my);
1142 mx= msmpeg4v2_decode_motion(s, mx, 1);
1143 my= msmpeg4v2_decode_motion(s, my, 1);
1145 s->mv_dir = MV_DIR_FORWARD;
1146 s->mv_type = MV_TYPE_16X16;
1147 s->mv[0][0][0] = mx;
1148 s->mv[0][0][1] = my;
1150 if(s->msmpeg4_version==2){
1151 s->ac_pred = get_bits1(&s->gb);
1152 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1155 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1156 if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
1160 s->dsp.clear_blocks(s->block[0]);
1161 for (i = 0; i < 6; i++) {
1162 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1164 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1171 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1175 uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
1177 if (s->pict_type == AV_PICTURE_TYPE_P) {
1178 if (s->use_skip_mb_code) {
1179 if (get_bits1(&s->gb)) {
1183 s->block_last_index[i] = -1;
1184 s->mv_dir = MV_DIR_FORWARD;
1185 s->mv_type = MV_TYPE_16X16;
1189 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1195 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1198 //s->mb_intra = (code & 0x40) ? 0 : 1;
1199 s->mb_intra = (~code & 0x40) >> 6;
1204 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1207 /* predict coded block pattern */
1210 int val = ((code >> (5 - i)) & 1);
1212 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1216 cbp |= val << (5 - i);
1222 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1223 if(s->per_mb_rl_table && cbp){
1224 s->rl_table_index = decode012(&s->gb);
1225 s->rl_chroma_table_index = s->rl_table_index;
1227 h263_pred_motion(s, 0, 0, &mx, &my);
1228 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1230 s->mv_dir = MV_DIR_FORWARD;
1231 s->mv_type = MV_TYPE_16X16;
1232 s->mv[0][0][0] = mx;
1233 s->mv[0][0][1] = my;
1234 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1236 //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));
1237 s->ac_pred = get_bits1(&s->gb);
1238 *mb_type_ptr = MB_TYPE_INTRA;
1239 if(s->inter_intra_pred){
1240 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1241 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1243 if(s->per_mb_rl_table && cbp){
1244 s->rl_table_index = decode012(&s->gb);
1245 s->rl_chroma_table_index = s->rl_table_index;
1249 s->dsp.clear_blocks(s->block[0]);
1250 for (i = 0; i < 6; i++) {
1251 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1253 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1261 /* init all vlc decoding tables */
1262 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1264 MpegEncContext *s = avctx->priv_data;
1265 static int done = 0;
1269 if (ff_h263_decode_init(avctx) < 0)
1277 for(i=0;i<NB_RL_TABLES;i++) {
1278 init_rl(&rl_table[i], static_rl_table_store[i]);
1280 INIT_VLC_RL(rl_table[0], 642);
1281 INIT_VLC_RL(rl_table[1], 1104);
1282 INIT_VLC_RL(rl_table[2], 554);
1283 INIT_VLC_RL(rl_table[3], 940);
1284 INIT_VLC_RL(rl_table[4], 962);
1285 INIT_VLC_RL(rl_table[5], 554);
1288 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1289 mv->table_mv_bits, 1, 1,
1290 mv->table_mv_code, 2, 2, 3714);
1292 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1293 mv->table_mv_bits, 1, 1,
1294 mv->table_mv_code, 2, 2, 2694);
1296 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1297 &ff_table0_dc_lum[0][1], 8, 4,
1298 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1299 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1300 &ff_table0_dc_chroma[0][1], 8, 4,
1301 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1302 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1303 &ff_table1_dc_lum[0][1], 8, 4,
1304 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1305 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1306 &ff_table1_dc_chroma[0][1], 8, 4,
1307 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1309 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1310 &v2_dc_lum_table[0][1], 8, 4,
1311 &v2_dc_lum_table[0][0], 8, 4, 1472);
1312 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1313 &v2_dc_chroma_table[0][1], 8, 4,
1314 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1316 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1317 &v2_intra_cbpc[0][1], 2, 1,
1318 &v2_intra_cbpc[0][0], 2, 1, 8);
1319 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1320 &v2_mb_type[0][1], 2, 1,
1321 &v2_mb_type[0][0], 2, 1, 128);
1322 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1324 &mvtab[0][0], 2, 1, 538);
1326 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1327 &wmv2_inter_table[0][0][1], 8, 4,
1328 &wmv2_inter_table[0][0][0], 8, 4, 1636);
1329 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1330 &wmv2_inter_table[1][0][1], 8, 4,
1331 &wmv2_inter_table[1][0][0], 8, 4, 2648);
1332 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1333 &wmv2_inter_table[2][0][1], 8, 4,
1334 &wmv2_inter_table[2][0][0], 8, 4, 1532);
1335 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1336 &wmv2_inter_table[3][0][1], 8, 4,
1337 &wmv2_inter_table[3][0][0], 8, 4, 2488);
1339 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1340 &ff_msmp4_mb_i_table[0][1], 4, 2,
1341 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1343 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1344 &table_inter_intra[0][1], 2, 1,
1345 &table_inter_intra[0][0], 2, 1, 8);
1348 switch(s->msmpeg4_version){
1351 s->decode_mb= msmpeg4v12_decode_mb;
1355 s->decode_mb= msmpeg4v34_decode_mb;
1358 if (CONFIG_WMV2_DECODER)
1359 s->decode_mb= ff_wmv2_decode_mb;
1361 //FIXME + TODO VC1 decode mb
1365 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1370 int msmpeg4_decode_picture_header(MpegEncContext * s)
1374 if(s->msmpeg4_version==1){
1375 int start_code = get_bits_long(&s->gb, 32);
1376 if(start_code!=0x00000100){
1377 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1381 skip_bits(&s->gb, 5); // frame number */
1384 s->pict_type = get_bits(&s->gb, 2) + 1;
1385 if (s->pict_type != AV_PICTURE_TYPE_I &&
1386 s->pict_type != AV_PICTURE_TYPE_P){
1387 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1393 if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
1394 if(!had_i) return -1;
1397 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1399 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1403 if (s->pict_type == AV_PICTURE_TYPE_I) {
1404 code = get_bits(&s->gb, 5);
1405 if(s->msmpeg4_version==1){
1406 if(code==0 || code>s->mb_height){
1407 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1411 s->slice_height = code;
1413 /* 0x17: one slice, 0x18: two slices, ... */
1415 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1419 s->slice_height = s->mb_height / (code - 0x16);
1422 switch(s->msmpeg4_version){
1425 s->rl_chroma_table_index = 2;
1426 s->rl_table_index = 2;
1428 s->dc_table_index = 0; //not used
1431 s->rl_chroma_table_index = decode012(&s->gb);
1432 s->rl_table_index = decode012(&s->gb);
1434 s->dc_table_index = get_bits1(&s->gb);
1437 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1439 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1440 else s->per_mb_rl_table= 0;
1442 if(!s->per_mb_rl_table){
1443 s->rl_chroma_table_index = decode012(&s->gb);
1444 s->rl_table_index = decode012(&s->gb);
1447 s->dc_table_index = get_bits1(&s->gb);
1448 s->inter_intra_pred= 0;
1452 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1453 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1455 s->rl_chroma_table_index,
1461 switch(s->msmpeg4_version){
1464 if(s->msmpeg4_version==1)
1465 s->use_skip_mb_code = 1;
1467 s->use_skip_mb_code = get_bits1(&s->gb);
1468 s->rl_table_index = 2;
1469 s->rl_chroma_table_index = s->rl_table_index;
1470 s->dc_table_index = 0; //not used
1471 s->mv_table_index = 0;
1474 s->use_skip_mb_code = get_bits1(&s->gb);
1475 s->rl_table_index = decode012(&s->gb);
1476 s->rl_chroma_table_index = s->rl_table_index;
1478 s->dc_table_index = get_bits1(&s->gb);
1480 s->mv_table_index = get_bits1(&s->gb);
1483 s->use_skip_mb_code = get_bits1(&s->gb);
1485 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1486 else s->per_mb_rl_table= 0;
1488 if(!s->per_mb_rl_table){
1489 s->rl_table_index = decode012(&s->gb);
1490 s->rl_chroma_table_index = s->rl_table_index;
1493 s->dc_table_index = get_bits1(&s->gb);
1495 s->mv_table_index = get_bits1(&s->gb);
1496 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1500 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1501 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1502 s->use_skip_mb_code,
1504 s->rl_chroma_table_index,
1510 if(s->flipflop_rounding){
1511 s->no_rounding ^= 1;
1516 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1518 s->esc3_level_length= 0;
1519 s->esc3_run_length= 0;
1524 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1526 int left= buf_size*8 - get_bits_count(&s->gb);
1527 int length= s->msmpeg4_version>=3 ? 17 : 16;
1528 /* the alt_bitstream reader could read over the end so we need to check it */
1529 if(left>=length && left<length+8)
1531 skip_bits(&s->gb, 5); /* fps */
1532 s->bit_rate= get_bits(&s->gb, 11)*1024;
1533 if(s->msmpeg4_version>=3)
1534 s->flipflop_rounding= get_bits1(&s->gb);
1536 s->flipflop_rounding= 0;
1538 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1540 else if(left<length+8)
1542 s->flipflop_rounding= 0;
1543 if(s->msmpeg4_version != 2)
1544 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1548 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1554 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1558 if(s->msmpeg4_version<=2){
1560 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1562 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1567 }else{ //FIXME optimize use unified tables & index
1569 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1571 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1574 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1578 if (level == DC_MAX) {
1579 level = get_bits(&s->gb, 8);
1580 if (get_bits1(&s->gb))
1582 } else if (level != 0) {
1583 if (get_bits1(&s->gb))
1588 if(s->msmpeg4_version==1){
1590 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1593 /* update predictor */
1597 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1600 /* update predictor */
1602 *dc_val = level * s->y_dc_scale;
1604 *dc_val = level * s->c_dc_scale;
1611 //#define ERROR_DETAILS
1612 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1613 int n, int coded, const uint8_t *scan_table)
1615 int level, i, last, run, run_diff;
1616 int av_uninit(dc_pred_dir);
1618 RL_VLC_ELEM *rl_vlc;
1626 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1629 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1630 if(s->inter_intra_pred) level=0;
1634 rl = &rl_table[s->rl_table_index];
1635 if(level > 256*s->y_dc_scale){
1636 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1637 if(!s->inter_intra_pred) return -1;
1640 rl = &rl_table[3 + s->rl_chroma_table_index];
1641 if(level > 256*s->c_dc_scale){
1642 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1643 if(!s->inter_intra_pred) return -1;
1648 run_diff = s->msmpeg4_version >= 4;
1654 if (dc_pred_dir == 0)
1655 scan_table = s->intra_v_scantable.permutated; /* left */
1657 scan_table = s->intra_h_scantable.permutated; /* top */
1659 scan_table = s->intra_scantable.permutated;
1661 rl_vlc= rl->rl_vlc[0];
1663 qmul = s->qscale << 1;
1664 qadd = (s->qscale - 1) | 1;
1666 rl = &rl_table[3 + s->rl_table_index];
1668 if(s->msmpeg4_version==2)
1674 s->block_last_index[n] = i;
1678 scan_table = s->inter_scantable.permutated;
1679 rl_vlc= rl->rl_vlc[s->qscale];
1682 OPEN_READER(re, &s->gb);
1684 UPDATE_CACHE(re, &s->gb);
1685 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1688 cache= GET_CACHE(re, &s->gb);
1690 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1691 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1693 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1694 UPDATE_CACHE(re, &s->gb);
1695 if(s->msmpeg4_version<=3){
1696 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1697 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1698 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1699 SKIP_COUNTER(re, &s->gb, 1+6+8);
1702 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1703 if(!s->esc3_level_length){
1705 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1707 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1709 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1713 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1715 SKIP_BITS(re, &s->gb, 1);
1717 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1720 s->esc3_level_length= ll;
1721 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1722 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1723 UPDATE_CACHE(re, &s->gb);
1725 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1726 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1728 sign= SHOW_UBITS(re, &s->gb, 1);
1729 SKIP_BITS(re, &s->gb, 1);
1731 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1732 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1733 if(sign) level= -level;
1735 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1736 #if 0 // waste of time / this will detect very few errors
1738 const int abs_level= FFABS(level);
1739 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1740 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1741 if(abs_level <= rl->max_level[last][run]){
1742 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1743 return DECODING_AC_LOST;
1745 if(abs_level <= rl->max_level[last][run]*2){
1746 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1747 return DECODING_AC_LOST;
1749 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1750 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1751 return DECODING_AC_LOST;
1756 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1757 if (level>0) level= level * qmul + qadd;
1758 else level= level * qmul - qadd;
1759 #if 0 // waste of time too :(
1760 if(level>2048 || level<-2048){
1761 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1762 return DECODING_AC_LOST;
1767 #ifdef ERROR_DETAILS
1769 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1770 else if((i>62 && i<192) || i>192+63)
1771 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1775 SKIP_BITS(re, &s->gb, 2);
1776 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1777 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1778 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1779 LAST_SKIP_BITS(re, &s->gb, 1);
1780 #ifdef ERROR_DETAILS
1782 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1783 else if((i>62 && i<192) || i>192+63)
1784 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1789 SKIP_BITS(re, &s->gb, 1);
1790 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1792 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1793 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1794 LAST_SKIP_BITS(re, &s->gb, 1);
1795 #ifdef ERROR_DETAILS
1797 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1798 else if((i>62 && i<192) || i>192+63)
1799 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1804 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1805 LAST_SKIP_BITS(re, &s->gb, 1);
1806 #ifdef ERROR_DETAILS
1808 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1809 else if((i>62 && i<192) || i>192+63)
1810 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1816 const int left= get_bits_left(&s->gb);
1817 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1818 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1821 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1826 block[scan_table[i]] = level;
1830 block[scan_table[i]] = level;
1832 CLOSE_READER(re, &s->gb);
1836 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1838 i = 63; /* XXX: not optimal */
1841 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1842 s->block_last_index[n] = i;
1847 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1848 int *mx_ptr, int *my_ptr)
1853 mv = &mv_tables[s->mv_table_index];
1855 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1857 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1860 if (code == mv->n) {
1861 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1862 mx = get_bits(&s->gb, 6);
1863 my = get_bits(&s->gb, 6);
1865 mx = mv->table_mvx[code];
1866 my = mv->table_mvy[code];
1871 /* WARNING : they do not do exactly modulo encoding */
1886 AVCodec ff_msmpeg4v1_decoder = {
1887 .name = "msmpeg4v1",
1888 .type = AVMEDIA_TYPE_VIDEO,
1889 .id = CODEC_ID_MSMPEG4V1,
1890 .priv_data_size = sizeof(MpegEncContext),
1891 .init = ff_msmpeg4_decode_init,
1892 .close = ff_h263_decode_end,
1893 .decode = ff_h263_decode_frame,
1894 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1896 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1897 .pix_fmts= ff_pixfmt_list_420,
1900 AVCodec ff_msmpeg4v2_decoder = {
1901 .name = "msmpeg4v2",
1902 .type = AVMEDIA_TYPE_VIDEO,
1903 .id = CODEC_ID_MSMPEG4V2,
1904 .priv_data_size = sizeof(MpegEncContext),
1905 .init = ff_msmpeg4_decode_init,
1906 .close = ff_h263_decode_end,
1907 .decode = ff_h263_decode_frame,
1908 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1910 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1911 .pix_fmts= ff_pixfmt_list_420,
1914 AVCodec ff_msmpeg4v3_decoder = {
1916 .type = AVMEDIA_TYPE_VIDEO,
1917 .id = CODEC_ID_MSMPEG4V3,
1918 .priv_data_size = sizeof(MpegEncContext),
1919 .init = ff_msmpeg4_decode_init,
1920 .close = ff_h263_decode_end,
1921 .decode = ff_h263_decode_frame,
1922 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1924 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1925 .pix_fmts= ff_pixfmt_list_420,
1928 AVCodec ff_wmv1_decoder = {
1930 .type = AVMEDIA_TYPE_VIDEO,
1931 .id = CODEC_ID_WMV1,
1932 .priv_data_size = sizeof(MpegEncContext),
1933 .init = ff_msmpeg4_decode_init,
1934 .close = ff_h263_decode_end,
1935 .decode = ff_h263_decode_frame,
1936 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1938 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1939 .pix_fmts= ff_pixfmt_list_420,