2 * MSMPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2001 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
23 #include "mpegvideo.h"
27 * You can also call this codec : MPEG4 with a twist !
30 * - (encoding) select best mv table (two choices)
31 * - (encoding) select best vlc/dc table
36 #define CBPY_VLC_BITS 6
37 #define INTER_INTRA_VLC_BITS 3
38 #define V1_INTRA_CBPC_VLC_BITS 6
39 #define V1_INTER_CBPC_VLC_BITS 6
40 #define V2_INTRA_CBPC_VLC_BITS 3
41 #define V2_MB_TYPE_VLC_BITS 7
43 #define V2_MV_VLC_BITS 9
44 #define TEX_VLC_BITS 9
45 #define MB_NON_INTRA_VLC_BITS 9
46 #define MB_INTRA_VLC_BITS 9
48 #define II_BITRATE 128*1024
49 #define MBAC_BITRATE 50*1024
51 static UINT32 v2_dc_lum_table[512][2];
52 static UINT32 v2_dc_chroma_table[512][2];
54 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
55 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
57 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
58 static int msmpeg4_decode_motion(MpegEncContext * s,
59 int *mx_ptr, int *my_ptr);
60 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
61 static void init_h263_dc_for_msmpeg4(void);
62 static inline void msmpeg4_memsetw(short *tab, int val, int n);
63 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
64 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
65 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
67 extern UINT32 inverse[256];
75 #include "msmpeg4data.h"
77 static int rl_length[2][NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
81 const char *st_names[ST_NB] = {
91 int st_current_index = 0;
92 unsigned int st_bit_counts[ST_NB];
93 unsigned int st_out_bit_counts[ST_NB];
95 #define set_stat(var) st_current_index = var;
97 void print_stats(void)
105 total += st_bit_counts[i];
108 for(i=0;i<ST_NB;i++) {
109 printf("%-10s : %10.1f %5.1f%%\n",
111 (double)st_bit_counts[i] / 8.0,
112 (double)st_bit_counts[i] * 100.0 / total);
114 printf("%-10s : %10.1f %5.1f%%\n",
122 total += st_out_bit_counts[i];
125 for(i=0;i<ST_NB;i++) {
126 printf("%-10s : %10.1f %5.1f%%\n",
128 (double)st_out_bit_counts[i] / 8.0,
129 (double)st_out_bit_counts[i] * 100.0 / total);
131 printf("%-10s : %10.1f %5.1f%%\n",
139 #define set_stat(var)
143 static void common_init(MpegEncContext * s)
147 switch(s->msmpeg4_version){
151 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
154 if(s->workaround_bugs){
155 s->y_dc_scale_table= old_ff_y_dc_scale_table;
156 s->c_dc_scale_table= old_ff_c_dc_scale_table;
158 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
159 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
163 s->y_dc_scale_table= wmv1_y_dc_scale_table;
164 s->c_dc_scale_table= wmv1_c_dc_scale_table;
169 if(s->msmpeg4_version==4){
170 ff_init_scantable(s, &s->intra_scantable , wmv1_scantable[1]);
171 ff_init_scantable(s, &s->intra_h_scantable, wmv1_scantable[2]);
172 ff_init_scantable(s, &s->intra_v_scantable, wmv1_scantable[3]);
173 ff_init_scantable(s, &s->inter_scantable , wmv1_scantable[0]);
175 //Note the default tables are set in common_init in mpegvideo.c
180 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) * 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 static void code012(PutBitContext *pb, int n)
207 put_bits(pb, 1, (n >= 2));
211 void ff_msmpeg4_encode_init(MpegEncContext *s)
213 static int init_done=0;
217 if(s->msmpeg4_version>=4){
223 /* init various encoding tables */
225 init_mv_table(&mv_tables[0]);
226 init_mv_table(&mv_tables[1]);
227 for(i=0;i<NB_RL_TABLES;i++)
228 init_rl(&rl_table[i]);
230 for(i=0; i<NB_RL_TABLES; i++){
232 for(level=0; level<=MAX_LEVEL; level++){
234 for(run=0; run<=MAX_RUN; run++){
236 for(last=0; last<2; last++){
237 rl_length[0][i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level,0);
238 rl_length[1][i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level,1);
246 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
249 int run_diff= intra ? 0 : 1;
251 code = get_rl_index(rl, last, run, level);
252 size+= rl->table_vlc[code][1];
256 level1 = level - rl->max_level[last][run];
259 code = get_rl_index(rl, last, run, level1);
263 if (level > MAX_LEVEL)
265 run1 = run - rl->max_run[last][level] - run_diff;
268 code = get_rl_index(rl, last, run1, level);
275 size+= 1+1+ rl->table_vlc[code][1];
279 size+= 1+1+ rl->table_vlc[code][1];
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==I_TYPE){
313 size += intra_luma_count *rl_length[1][i ][level][run][last];
314 chroma_size+= intra_chroma_count*rl_length[1][i+3][level][run][last];
316 size+= intra_luma_count *rl_length[1][i ][level][run][last]
317 +intra_chroma_count*rl_length[1][i+3][level][run][last]
318 +inter_count *rl_length[0][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==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==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 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
374 if (s->pict_type == I_TYPE) {
376 s->slice_height= s->mb_height/1;
377 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
379 if(s->msmpeg4_version==4){
380 msmpeg4_encode_ext_header(s);
381 if(s->bit_rate>MBAC_BITRATE)
382 put_bits(&s->pb, 1, s->per_mb_rl_table);
385 if(s->msmpeg4_version>2){
386 if(!s->per_mb_rl_table){
387 code012(&s->pb, s->rl_chroma_table_index);
388 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 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);
408 if(s->flipflop_rounding){
415 s->esc3_level_length= 0;
416 s->esc3_run_length= 0;
420 printf("*****frame %d:\n", frame_count++);
424 void msmpeg4_encode_ext_header(MpegEncContext * s)
426 put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
428 put_bits(&s->pb, 11, MIN(s->bit_rate/1024, 2047));
430 if(s->msmpeg4_version<3)
431 s->flipflop_rounding=0;
433 s->flipflop_rounding=1;
434 put_bits(&s->pb, 1, s->flipflop_rounding);
438 /* predict coded block */
439 static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
441 int xy, wrap, pred, a, b, c;
443 xy = s->block_index[n];
444 wrap = s->block_wrap[0];
449 a = s->coded_block[xy - 1 ];
450 b = s->coded_block[xy - 1 - wrap];
451 c = s->coded_block[xy - wrap];
460 *coded_block_ptr = &s->coded_block[xy];
465 static void msmpeg4_encode_motion(MpegEncContext * s,
471 /* modulo encoding */
472 /* WARNING : you cannot reach all the MVs even with the modulo
473 encoding. This is a somewhat strange compromise they took !!! */
486 if ((unsigned)mx >= 64 ||
488 fprintf(stderr, "error mx=%d my=%d\n", mx, my);
490 mv = &mv_tables[s->mv_table_index];
492 code = mv->table_mv_index[(mx << 6) | my];
495 mv->table_mv_bits[code],
496 mv->table_mv_code[code]);
498 /* escape : code litterally */
499 put_bits(&s->pb, 6, mx);
500 put_bits(&s->pb, 6, my);
504 static inline void handle_slices(MpegEncContext *s){
506 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
507 if(s->msmpeg4_version != 4){
508 ff_mpeg4_clean_buffers(s);
510 s->first_slice_line = 1;
512 s->first_slice_line = 0;
517 void msmpeg4_encode_mb(MpegEncContext * s,
518 DCTELEM block[6][64],
519 int motion_x, int motion_y)
521 int cbp, coded_cbp, i;
529 set_stat(ST_INTER_MB);
531 for (i = 0; i < 6; i++) {
532 if (s->block_last_index[i] >= 0)
535 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
536 /* skip macroblock */
537 put_bits(&s->pb, 1, 1);
540 if (s->use_skip_mb_code)
541 put_bits(&s->pb, 1, 0); /* mb coded */
543 if(s->msmpeg4_version<=2){
545 v2_mb_type[cbp&3][1],
546 v2_mb_type[cbp&3][0]);
547 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
551 cbpy_tab[coded_cbp>>2][1],
552 cbpy_tab[coded_cbp>>2][0]);
554 h263_pred_motion(s, 0, &pred_x, &pred_y);
555 msmpeg4v2_encode_motion(s, motion_x - pred_x);
556 msmpeg4v2_encode_motion(s, motion_y - pred_y);
559 table_mb_non_intra[cbp + 64][1],
560 table_mb_non_intra[cbp + 64][0]);
563 h263_pred_motion(s, 0, &pred_x, &pred_y);
564 msmpeg4_encode_motion(s, motion_x - pred_x,
571 for (i = 0; i < 6; i++) {
573 val = (s->block_last_index[i] >= 1);
574 cbp |= val << (5 - i);
576 /* predict value for close blocks only for luma */
577 pred = coded_block_pred(s, i, &coded_block);
581 coded_cbp |= val << (5 - i);
585 printf("cbp=%x %x\n", cbp, coded_cbp);
588 if(s->msmpeg4_version<=2){
589 if (s->pict_type == I_TYPE) {
591 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
593 if (s->use_skip_mb_code)
594 put_bits(&s->pb, 1, 0); /* mb coded */
596 v2_mb_type[(cbp&3) + 4][1],
597 v2_mb_type[(cbp&3) + 4][0]);
599 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
602 cbpy_tab[cbp>>2][0]);
604 if (s->pict_type == I_TYPE) {
605 set_stat(ST_INTRA_MB);
607 table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
609 if (s->use_skip_mb_code)
610 put_bits(&s->pb, 1, 0); /* mb coded */
612 table_mb_non_intra[cbp][1],
613 table_mb_non_intra[cbp][0]);
615 set_stat(ST_INTRA_MB);
616 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
617 if(s->inter_intra_pred){
619 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
624 for (i = 0; i < 6; i++) {
625 msmpeg4_encode_block(s, block[i], i);
629 /* old ffmpeg msmpeg4v3 mode */
630 void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
635 }else if (s->qscale < 9){
636 s->y_dc_scale = 2 * s->qscale;
637 s->c_dc_scale = (s->qscale + 13)>>1;
639 s->y_dc_scale = s->qscale + 8;
640 s->c_dc_scale = (s->qscale + 13)>>1;
644 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
655 *dc_val_ptr= &s->last_dc[i];
656 return s->last_dc[i];
659 static int get_dc(uint8_t *src, int stride, int scale)
666 sum+=src[x + y*stride];
669 return (sum + (scale>>1))/scale;
672 /* dir = 0: left, dir = 1: top prediction */
673 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
674 UINT16 **dc_val_ptr, int *dir_ptr)
676 int a, b, c, wrap, pred, scale;
679 /* find prediction */
681 scale = s->y_dc_scale;
683 scale = s->c_dc_scale;
686 wrap = s->block_wrap[n];
687 dc_val= s->dc_val[0] + s->block_index[n];
693 b = dc_val[ - 1 - wrap];
696 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version!=4){
700 /* XXX: the following solution consumes divisions, but it does not
701 necessitate to modify mpegvideo.c. The problem comes from the
702 fact they decided to store the quantized DC (which would lead
703 to problems if Q could vary !) */
704 #if defined ARCH_X86 && !defined PIC
706 "movl %3, %%eax \n\t"
707 "shrl $1, %%eax \n\t"
708 "addl %%eax, %2 \n\t"
709 "addl %%eax, %1 \n\t"
710 "addl %0, %%eax \n\t"
712 "movl %%edx, %0 \n\t"
713 "movl %1, %%eax \n\t"
715 "movl %%edx, %1 \n\t"
716 "movl %2, %%eax \n\t"
718 "movl %%edx, %2 \n\t"
719 : "+b" (a), "+c" (b), "+D" (c)
720 : "g" (scale), "S" (inverse[scale])
724 /* #elif defined (ARCH_ALPHA) */
725 /* Divisions are extremely costly on Alpha; optimize the most
726 common case. But they are costly everywhere...
729 a = (a + (8 >> 1)) / 8;
730 b = (b + (8 >> 1)) / 8;
731 c = (c + (8 >> 1)) / 8;
733 a = (a + (scale >> 1)) / scale;
734 b = (b + (scale >> 1)) / scale;
735 c = (c + (scale >> 1)) / scale;
738 /* XXX: WARNING: they did not choose the same test as MPEG4. This
739 is very important ! */
740 if(s->msmpeg4_version>3){
741 if(s->inter_intra_pred){
752 if (abs(a - b) < abs(b - c)) {
762 dest= s->current_picture[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
765 dest= s->current_picture[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
767 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
768 else a= get_dc(dest-8, wrap, scale*8);
769 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
770 else c= get_dc(dest-8*wrap, wrap, scale*8);
772 if (s->h263_aic_dir==0) {
775 }else if (s->h263_aic_dir==1) {
783 }else if (s->h263_aic_dir==2) {
797 if (abs(a - b) < abs(b - c)) {
806 if (abs(a - b) <= abs(b - c)) {
815 /* update predictor */
816 *dc_val_ptr = &dc_val[0];
822 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
827 if(s->msmpeg4_version==1){
829 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
831 /* update predictor */
835 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
837 /* update predictor */
839 *dc_val = level * s->y_dc_scale;
841 *dc_val = level * s->c_dc_scale;
845 /* do the prediction */
848 if(s->msmpeg4_version<=2){
851 v2_dc_lum_table[level+256][1],
852 v2_dc_lum_table[level+256][0]);
855 v2_dc_chroma_table[level+256][1],
856 v2_dc_chroma_table[level+256][0]);
868 if (s->dc_table_index == 0) {
870 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
872 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
876 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
878 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
883 put_bits(&s->pb, 8, level);
886 put_bits(&s->pb, 1, sign);
891 /* Encoding of a block. Very similar to MPEG4 except for a different
892 escape coding (same as H263) and more vlc tables.
894 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
896 int level, run, last, i, j, last_index;
897 int last_non_zero, sign, slevel;
898 int code, run_diff, dc_pred_dir;
900 const UINT8 *scantable;
904 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
907 rl = &rl_table[s->rl_table_index];
909 rl = &rl_table[3 + s->rl_chroma_table_index];
912 scantable= s->intra_scantable.permutated;
913 set_stat(ST_INTRA_AC);
916 rl = &rl_table[3 + s->rl_table_index];
917 if(s->msmpeg4_version<=2)
921 scantable= s->inter_scantable.permutated;
922 set_stat(ST_INTER_AC);
925 /* recalculate block_last_index for M$ wmv1 */
926 if(s->msmpeg4_version==4 && s->block_last_index[n]>0){
927 for(last_index=63; last_index>=0; last_index--){
928 if(block[scantable[last_index]]) break;
930 s->block_last_index[n]= last_index;
932 last_index = s->block_last_index[n];
934 last_non_zero = i - 1;
935 for (; i <= last_index; i++) {
939 run = i - last_non_zero - 1;
940 last = (i == last_index);
948 if(level<=MAX_LEVEL && run<=MAX_RUN){
949 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
953 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
955 code = get_rl_index(rl, last, run, level);
956 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
960 level1 = level - rl->max_level[last][run];
963 code = get_rl_index(rl, last, run, level1);
966 put_bits(&s->pb, 1, 0);
967 if (level > MAX_LEVEL)
969 run1 = run - rl->max_run[last][level] - run_diff;
972 code = get_rl_index(rl, last, run1, level);
976 put_bits(&s->pb, 1, 0);
977 put_bits(&s->pb, 1, last);
978 if(s->msmpeg4_version==4){
979 if(s->esc3_level_length==0){
980 s->esc3_level_length=8;
981 s->esc3_run_length= 6;
983 put_bits(&s->pb, 6, 3);
985 put_bits(&s->pb, 8, 3);
987 put_bits(&s->pb, s->esc3_run_length, run);
988 put_bits(&s->pb, 1, sign);
989 put_bits(&s->pb, s->esc3_level_length, level);
991 put_bits(&s->pb, 6, run);
992 put_bits(&s->pb, 8, slevel & 0xff);
996 put_bits(&s->pb, 1, 1);
997 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
998 put_bits(&s->pb, 1, sign);
1002 put_bits(&s->pb, 1, 1);
1003 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1004 put_bits(&s->pb, 1, sign);
1007 put_bits(&s->pb, 1, sign);
1014 /****************************************/
1015 /* decoding stuff */
1017 static VLC mb_non_intra_vlc;
1018 static VLC mb_intra_vlc;
1019 static VLC dc_lum_vlc[2];
1020 static VLC dc_chroma_vlc[2];
1021 static VLC v2_dc_lum_vlc;
1022 static VLC v2_dc_chroma_vlc;
1023 static VLC cbpy_vlc;
1024 static VLC v2_intra_cbpc_vlc;
1025 static VLC v2_mb_type_vlc;
1026 static VLC v2_mv_vlc;
1027 static VLC v1_intra_cbpc_vlc;
1028 static VLC v1_inter_cbpc_vlc;
1029 static VLC inter_intra_vlc;
1031 /* this table is practically identical to the one from h263 except that its inverted */
1032 static void init_h263_dc_for_msmpeg4(void)
1034 int level, uni_code, uni_len;
1036 for(level=-256; level<256; level++){
1038 /* find number of bits */
1047 l= (-level) ^ ((1 << size) - 1);
1051 /* luminance h263 */
1052 uni_code= DCtab_lum[size][0];
1053 uni_len = DCtab_lum[size][1];
1054 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1057 uni_code<<=size; uni_code|=l;
1060 uni_code<<=1; uni_code|=1;
1064 v2_dc_lum_table[level+256][0]= uni_code;
1065 v2_dc_lum_table[level+256][1]= uni_len;
1067 /* chrominance h263 */
1068 uni_code= DCtab_chrom[size][0];
1069 uni_len = DCtab_chrom[size][1];
1070 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1073 uni_code<<=size; uni_code|=l;
1076 uni_code<<=1; uni_code|=1;
1080 v2_dc_chroma_table[level+256][0]= uni_code;
1081 v2_dc_chroma_table[level+256][1]= uni_len;
1086 /* init all vlc decoding tables */
1087 int ff_msmpeg4_decode_init(MpegEncContext *s)
1089 static int done = 0;
1098 for(i=0;i<NB_RL_TABLES;i++) {
1099 init_rl(&rl_table[i]);
1100 init_vlc_rl(&rl_table[i]);
1104 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1105 mv->table_mv_bits, 1, 1,
1106 mv->table_mv_code, 2, 2);
1109 init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120,
1110 &table0_dc_lum[0][1], 8, 4,
1111 &table0_dc_lum[0][0], 8, 4);
1112 init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120,
1113 &table0_dc_chroma[0][1], 8, 4,
1114 &table0_dc_chroma[0][0], 8, 4);
1115 init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120,
1116 &table1_dc_lum[0][1], 8, 4,
1117 &table1_dc_lum[0][0], 8, 4);
1118 init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120,
1119 &table1_dc_chroma[0][1], 8, 4,
1120 &table1_dc_chroma[0][0], 8, 4);
1122 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1123 &v2_dc_lum_table[0][1], 8, 4,
1124 &v2_dc_lum_table[0][0], 8, 4);
1125 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1126 &v2_dc_chroma_table[0][1], 8, 4,
1127 &v2_dc_chroma_table[0][0], 8, 4);
1129 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1130 &cbpy_tab[0][1], 2, 1,
1131 &cbpy_tab[0][0], 2, 1);
1132 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1133 &v2_intra_cbpc[0][1], 2, 1,
1134 &v2_intra_cbpc[0][0], 2, 1);
1135 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1136 &v2_mb_type[0][1], 2, 1,
1137 &v2_mb_type[0][0], 2, 1);
1138 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1140 &mvtab[0][0], 2, 1);
1142 init_vlc(&mb_non_intra_vlc, MB_NON_INTRA_VLC_BITS, 128,
1143 &table_mb_non_intra[0][1], 8, 4,
1144 &table_mb_non_intra[0][0], 8, 4);
1145 init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,
1146 &table_mb_intra[0][1], 4, 2,
1147 &table_mb_intra[0][0], 4, 2);
1149 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1150 intra_MCBPC_bits, 1, 1,
1151 intra_MCBPC_code, 1, 1);
1152 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1153 inter_MCBPC_bits, 1, 1,
1154 inter_MCBPC_code, 1, 1);
1156 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1157 &table_inter_intra[0][1], 2, 1,
1158 &table_inter_intra[0][0], 2, 1);
1161 switch(s->msmpeg4_version){
1164 s->decode_mb= msmpeg4v12_decode_mb;
1168 s->decode_mb= msmpeg4v34_decode_mb;
1175 static int decode012(GetBitContext *gb)
1182 return get_bits1(gb) + 1;
1185 int msmpeg4_decode_picture_header(MpegEncContext * s)
1192 for(i=0; i<s->gb.size*8; i++)
1193 printf("%d", get_bits1(&s->gb));
1194 // get_bits1(&s->gb);
1200 if(s->msmpeg4_version==1){
1201 int start_code, num;
1202 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1203 if(start_code!=0x00000100){
1204 fprintf(stderr, "invalid startcode\n");
1208 num= get_bits(&s->gb, 5); // frame number */
1211 s->pict_type = get_bits(&s->gb, 2) + 1;
1212 if (s->pict_type != I_TYPE &&
1213 s->pict_type != P_TYPE){
1214 fprintf(stderr, "invalid picture type\n");
1220 if(s->pict_type == I_TYPE) had_i=1;
1221 if(!had_i) return -1;
1224 s->qscale = get_bits(&s->gb, 5);
1226 if (s->pict_type == I_TYPE) {
1227 code = get_bits(&s->gb, 5);
1228 if(s->msmpeg4_version==1){
1229 if(code==0 || code>s->mb_height){
1230 fprintf(stderr, "invalid slice height %d\n", code);
1234 s->slice_height = code;
1236 /* 0x17: one slice, 0x18: two slices, ... */
1238 fprintf(stderr, "error, slice code was %X\n", code);
1242 s->slice_height = s->mb_height / (code - 0x16);
1245 switch(s->msmpeg4_version){
1248 s->rl_chroma_table_index = 2;
1249 s->rl_table_index = 2;
1251 s->dc_table_index = 0; //not used
1254 s->rl_chroma_table_index = decode012(&s->gb);
1255 s->rl_table_index = decode012(&s->gb);
1257 s->dc_table_index = get_bits1(&s->gb);
1260 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1262 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1263 else s->per_mb_rl_table= 0;
1265 if(!s->per_mb_rl_table){
1266 s->rl_chroma_table_index = decode012(&s->gb);
1267 s->rl_table_index = decode012(&s->gb);
1270 s->dc_table_index = get_bits1(&s->gb);
1271 s->inter_intra_pred= 0;
1275 /* printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1277 s->rl_chroma_table_index,
1283 switch(s->msmpeg4_version){
1286 if(s->msmpeg4_version==1)
1287 s->use_skip_mb_code = 1;
1289 s->use_skip_mb_code = get_bits1(&s->gb);
1290 s->rl_table_index = 2;
1291 s->rl_chroma_table_index = s->rl_table_index;
1292 s->dc_table_index = 0; //not used
1293 s->mv_table_index = 0;
1296 s->use_skip_mb_code = get_bits1(&s->gb);
1297 s->rl_table_index = decode012(&s->gb);
1298 s->rl_chroma_table_index = s->rl_table_index;
1300 s->dc_table_index = get_bits1(&s->gb);
1302 s->mv_table_index = get_bits1(&s->gb);
1305 s->use_skip_mb_code = get_bits1(&s->gb);
1307 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1308 else s->per_mb_rl_table= 0;
1310 if(!s->per_mb_rl_table){
1311 s->rl_table_index = decode012(&s->gb);
1312 s->rl_chroma_table_index = s->rl_table_index;
1315 s->dc_table_index = get_bits1(&s->gb);
1317 s->mv_table_index = get_bits1(&s->gb);
1318 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1321 /* printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1322 s->use_skip_mb_code,
1324 s->rl_chroma_table_index,
1329 if(s->flipflop_rounding){
1330 s->no_rounding ^= 1;
1336 s->esc3_level_length= 0;
1337 s->esc3_run_length= 0;
1340 printf("*****frame %d:\n", frame_count++);
1345 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1347 int left= buf_size*8 - get_bits_count(&s->gb);
1348 int length= s->msmpeg4_version>=3 ? 17 : 16;
1349 /* the alt_bitstream reader could read over the end so we need to check it */
1350 if(left>=length && left<length+8)
1354 fps= get_bits(&s->gb, 5);
1355 s->bit_rate= get_bits(&s->gb, 11)*1024;
1356 if(s->msmpeg4_version>=3)
1357 s->flipflop_rounding= get_bits1(&s->gb);
1359 s->flipflop_rounding= 0;
1361 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1363 else if(left<length+8)
1365 s->flipflop_rounding= 0;
1366 printf("ext header missing, %d left\n", left);
1370 fprintf(stderr, "I frame too long, ignoring ext header\n");
1376 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1383 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1385 int range, bit_size, sign, code, bits;
1390 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1392 bit_size = s->f_code - 1;
1393 range = 1 << bit_size;
1406 code = (val >> bit_size) + 1;
1407 bits = val & (range - 1);
1409 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1411 put_bits(&s->pb, bit_size, bits);
1416 /* this is identical to h263 except that its range is multiplied by 2 */
1417 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1419 int code, val, sign, shift;
1421 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1422 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1428 sign = get_bits1(&s->gb);
1430 val = (code - 1) << shift;
1432 val |= get_bits(&s->gb, shift);
1446 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1450 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1452 if (s->pict_type == P_TYPE) {
1453 if (s->use_skip_mb_code) {
1454 if (get_bits1(&s->gb)) {
1458 s->block_last_index[i] = -1;
1459 s->mv_dir = MV_DIR_FORWARD;
1460 s->mv_type = MV_TYPE_16X16;
1468 if(s->msmpeg4_version==2)
1469 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1471 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1472 if(code<0 || code>7){
1473 fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1477 s->mb_intra = code >>2;
1482 if(s->msmpeg4_version==2)
1483 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1485 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1487 fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1495 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1497 fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1502 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1504 h263_pred_motion(s, 0, &mx, &my);
1505 mx= msmpeg4v2_decode_motion(s, mx, 1);
1506 my= msmpeg4v2_decode_motion(s, my, 1);
1508 s->mv_dir = MV_DIR_FORWARD;
1509 s->mv_type = MV_TYPE_16X16;
1510 s->mv[0][0][0] = mx;
1511 s->mv[0][0][1] = my;
1513 if(s->msmpeg4_version==2){
1514 s->ac_pred = get_bits1(&s->gb);
1515 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1518 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1519 if(s->pict_type==P_TYPE) cbp^=0x3C;
1523 for (i = 0; i < 6; i++) {
1524 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1526 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1533 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1541 if(s->mb_y==0) printf("\n");
1545 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1547 if (s->pict_type == P_TYPE) {
1548 set_stat(ST_INTER_MB);
1549 if (s->use_skip_mb_code) {
1550 if (get_bits1(&s->gb)) {
1554 s->block_last_index[i] = -1;
1555 s->mv_dir = MV_DIR_FORWARD;
1556 s->mv_type = MV_TYPE_16X16;
1567 code = get_vlc2(&s->gb, mb_non_intra_vlc.table, MB_NON_INTRA_VLC_BITS, 3);
1570 //s->mb_intra = (code & 0x40) ? 0 : 1;
1571 s->mb_intra = (~code & 0x40) >> 6;
1575 set_stat(ST_INTRA_MB);
1577 code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1580 /* predict coded block pattern */
1583 int val = ((code >> (5 - i)) & 1);
1585 int pred = coded_block_pred(s, i, &coded_val);
1589 cbp |= val << (5 - i);
1595 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1596 if(s->per_mb_rl_table && cbp){
1597 s->rl_table_index = decode012(&s->gb);
1598 s->rl_chroma_table_index = s->rl_table_index;
1601 h263_pred_motion(s, 0, &mx, &my);
1602 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1604 s->mv_dir = MV_DIR_FORWARD;
1605 s->mv_type = MV_TYPE_16X16;
1606 s->mv[0][0][0] = mx;
1607 s->mv[0][0][1] = my;
1612 //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));
1613 set_stat(ST_INTRA_MB);
1614 s->ac_pred = get_bits1(&s->gb);
1616 printf("%c", s->ac_pred ? 'A' : 'I');
1618 if(s->inter_intra_pred){
1619 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1620 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1622 if(s->per_mb_rl_table && cbp){
1623 s->rl_table_index = decode012(&s->gb);
1624 s->rl_chroma_table_index = s->rl_table_index;
1628 for (i = 0; i < 6; i++) {
1629 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1631 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1638 //#define ERROR_DETAILS
1639 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1642 int level, i, last, run, run_diff;
1645 RL_VLC_ELEM *rl_vlc;
1646 const UINT8 *scan_table;
1655 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1660 if(n==4) printf("%X", c);
1665 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1666 if(s->inter_intra_pred) level=0;
1670 rl = &rl_table[s->rl_table_index];
1671 if(level > 256*s->y_dc_scale){
1672 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1673 if(!s->inter_intra_pred) return -1;
1676 rl = &rl_table[3 + s->rl_chroma_table_index];
1677 if(level > 256*s->c_dc_scale){
1678 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1679 if(!s->inter_intra_pred) return -1;
1690 if (dc_pred_dir == 0)
1691 scan_table = s->intra_v_scantable.permutated; /* left */
1693 scan_table = s->intra_h_scantable.permutated; /* top */
1695 scan_table = s->intra_scantable.permutated;
1697 set_stat(ST_INTRA_AC);
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;
1714 scan_table = s->inter_scantable.permutated;
1715 set_stat(ST_INTER_AC);
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);
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)) printf("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= ABS(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 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1782 return DECODING_AC_LOST;
1784 if(abs_level <= rl->max_level[last][run]*2){
1785 fprintf(stderr, "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 fprintf(stderr, "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 fprintf(stderr, "|level| overflow in 3. esc\n");
1801 return DECODING_AC_LOST;
1806 #ifdef ERROR_DETAILS
1808 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1809 else if((i>62 && i<192) || i>192+63)
1810 fprintf(stderr, "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);
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 fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1827 else if((i>62 && i<192) || i>192+63)
1828 fprintf(stderr, "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);
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 fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1847 else if((i>62 && i<192) || i>192+63)
1848 fprintf(stderr, "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 fprintf(stderr, "illegal vlc code level=%d\n", level);
1858 else if((i>62 && i<192) || i>192+63)
1859 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1865 const int left= s->gb.size*8 - get_bits_count(&s->gb);
1866 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1867 fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1870 fprintf(stderr, "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 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1900 if(s->msmpeg4_version<=2){
1902 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1904 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1909 }else{ //FIXME optimize use unified tables & index
1911 level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1913 level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1916 fprintf(stderr, "illegal dc vlc\n");
1920 if (level == DC_MAX) {
1921 level = get_bits(&s->gb, 8);
1922 if (get_bits1(&s->gb))
1924 } else if (level != 0) {
1925 if (get_bits1(&s->gb))
1930 if(s->msmpeg4_version==1){
1932 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1935 /* update predictor */
1939 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1942 /* update predictor */
1944 *dc_val = level * s->y_dc_scale;
1946 *dc_val = level * s->c_dc_scale;
1953 static int msmpeg4_decode_motion(MpegEncContext * s,
1954 int *mx_ptr, int *my_ptr)
1959 mv = &mv_tables[s->mv_table_index];
1961 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1963 fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1966 if (code == mv->n) {
1967 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1968 mx = get_bits(&s->gb, 6);
1969 my = get_bits(&s->gb, 6);
1971 mx = mv->table_mvx[code];
1972 my = mv->table_mvy[code];
1977 /* WARNING : they do not do exactly modulo encoding */