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 #define DEFAULT_INTER_INDEX 3
53 static UINT32 v2_dc_lum_table[512][2];
54 static UINT32 v2_dc_chroma_table[512][2];
56 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
57 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
58 int n, int coded, const uint8_t *scantable);
59 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
60 static int msmpeg4_decode_motion(MpegEncContext * s,
61 int *mx_ptr, int *my_ptr);
62 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
63 static void init_h263_dc_for_msmpeg4(void);
64 static inline void msmpeg4_memsetw(short *tab, int val, int n);
65 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
66 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
67 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
68 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
70 extern UINT32 inverse[256];
78 #include "msmpeg4data.h"
80 static UINT8 rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
84 const char *st_names[ST_NB] = {
94 int st_current_index = 0;
95 unsigned int st_bit_counts[ST_NB];
96 unsigned int st_out_bit_counts[ST_NB];
98 #define set_stat(var) st_current_index = var;
100 void print_stats(void)
108 total += st_bit_counts[i];
111 for(i=0;i<ST_NB;i++) {
112 printf("%-10s : %10.1f %5.1f%%\n",
114 (double)st_bit_counts[i] / 8.0,
115 (double)st_bit_counts[i] * 100.0 / total);
117 printf("%-10s : %10.1f %5.1f%%\n",
125 total += st_out_bit_counts[i];
128 for(i=0;i<ST_NB;i++) {
129 printf("%-10s : %10.1f %5.1f%%\n",
131 (double)st_out_bit_counts[i] / 8.0,
132 (double)st_out_bit_counts[i] * 100.0 / total);
134 printf("%-10s : %10.1f %5.1f%%\n",
142 #define set_stat(var)
146 static void common_init(MpegEncContext * s)
150 switch(s->msmpeg4_version){
154 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
157 if(s->workaround_bugs){
158 s->y_dc_scale_table= old_ff_y_dc_scale_table;
159 s->c_dc_scale_table= old_ff_c_dc_scale_table;
161 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
162 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
167 s->y_dc_scale_table= wmv1_y_dc_scale_table;
168 s->c_dc_scale_table= wmv1_c_dc_scale_table;
173 if(s->msmpeg4_version>=4){
174 ff_init_scantable(s, &s->intra_scantable , wmv1_scantable[1]);
175 ff_init_scantable(s, &s->intra_h_scantable, wmv1_scantable[2]);
176 ff_init_scantable(s, &s->intra_v_scantable, wmv1_scantable[3]);
177 ff_init_scantable(s, &s->inter_scantable , wmv1_scantable[0]);
179 //Note the default tables are set in common_init in mpegvideo.c
184 init_h263_dc_for_msmpeg4();
188 /* build the table which associate a (x,y) motion vector to a vlc */
189 static void init_mv_table(MVTable *tab)
193 tab->table_mv_index = av_malloc(sizeof(UINT16) * 4096);
194 /* mark all entries as not used */
196 tab->table_mv_index[i] = tab->n;
198 for(i=0;i<tab->n;i++) {
199 x = tab->table_mvx[i];
200 y = tab->table_mvy[i];
201 tab->table_mv_index[(x << 6) | y] = i;
205 static void code012(PutBitContext *pb, int n)
211 put_bits(pb, 1, (n >= 2));
215 void ff_msmpeg4_encode_init(MpegEncContext *s)
217 static int init_done=0;
221 if(s->msmpeg4_version>=4){
227 /* init various encoding tables */
229 init_mv_table(&mv_tables[0]);
230 init_mv_table(&mv_tables[1]);
231 for(i=0;i<NB_RL_TABLES;i++)
232 init_rl(&rl_table[i]);
234 for(i=0; i<NB_RL_TABLES; i++){
236 for(level=0; level<=MAX_LEVEL; level++){
238 for(run=0; run<=MAX_RUN; run++){
240 for(last=0; last<2; last++){
241 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
249 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
252 int run_diff= intra ? 0 : 1;
254 code = get_rl_index(rl, last, run, level);
255 size+= rl->table_vlc[code][1];
259 level1 = level - rl->max_level[last][run];
262 code = get_rl_index(rl, last, run, level1);
266 if (level > MAX_LEVEL)
268 run1 = run - rl->max_run[last][level] - run_diff;
271 code = get_rl_index(rl, last, run1, level);
278 size+= 1+1+ rl->table_vlc[code][1];
282 size+= 1+1+ rl->table_vlc[code][1];
290 static void find_best_tables(MpegEncContext * s)
293 int best =-1, best_size =9999999;
294 int chroma_best=-1, best_chroma_size=9999999;
305 for(level=0; level<=MAX_LEVEL; level++){
307 for(run=0; run<=MAX_RUN; run++){
309 const int last_size= size + chroma_size;
310 for(last=0; last<2; last++){
311 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
312 int intra_luma_count = s->ac_stats[1][0][level][run][last];
313 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
315 if(s->pict_type==I_TYPE){
316 size += intra_luma_count *rl_length[i ][level][run][last];
317 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
319 size+= intra_luma_count *rl_length[i ][level][run][last]
320 +intra_chroma_count*rl_length[i+3][level][run][last]
321 +inter_count *rl_length[i+3][level][run][last];
324 if(last_size == size+chroma_size) break;
331 if(chroma_size<best_chroma_size){
332 best_chroma_size= chroma_size;
337 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
338 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
340 if(s->pict_type==P_TYPE) chroma_best= best;
342 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
344 s->rl_table_index = best;
345 s->rl_chroma_table_index= chroma_best;
347 if(s->pict_type != s->last_non_b_pict_type){
348 s->rl_table_index= 2;
349 if(s->pict_type==I_TYPE)
350 s->rl_chroma_table_index= 1;
352 s->rl_chroma_table_index= 2;
357 /* write MSMPEG4 compatible frame header */
358 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
362 align_put_bits(&s->pb);
363 put_bits(&s->pb, 2, s->pict_type - 1);
365 put_bits(&s->pb, 5, s->qscale);
366 if(s->msmpeg4_version<=2){
367 s->rl_table_index = 2;
368 s->rl_chroma_table_index = 2;
371 s->dc_table_index = 1;
372 s->mv_table_index = 1; /* only if P frame */
373 s->use_skip_mb_code = 1; /* only if P frame */
374 s->per_mb_rl_table = 0;
375 if(s->msmpeg4_version==4)
376 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
377 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
379 if (s->pict_type == I_TYPE) {
380 s->slice_height= s->mb_height/1;
381 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
383 if(s->msmpeg4_version==4){
384 msmpeg4_encode_ext_header(s);
385 if(s->bit_rate>MBAC_BITRATE)
386 put_bits(&s->pb, 1, s->per_mb_rl_table);
389 if(s->msmpeg4_version>2){
390 if(!s->per_mb_rl_table){
391 code012(&s->pb, s->rl_chroma_table_index);
392 code012(&s->pb, s->rl_table_index);
395 put_bits(&s->pb, 1, s->dc_table_index);
398 put_bits(&s->pb, 1, s->use_skip_mb_code);
400 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
401 put_bits(&s->pb, 1, s->per_mb_rl_table);
403 if(s->msmpeg4_version>2){
404 if(!s->per_mb_rl_table)
405 code012(&s->pb, s->rl_table_index);
407 put_bits(&s->pb, 1, s->dc_table_index);
409 put_bits(&s->pb, 1, s->mv_table_index);
413 s->esc3_level_length= 0;
414 s->esc3_run_length= 0;
418 printf("*****frame %d:\n", frame_count++);
422 void msmpeg4_encode_ext_header(MpegEncContext * s)
424 put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
426 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
428 if(s->msmpeg4_version<3)
429 s->flipflop_rounding=0;
431 s->flipflop_rounding=1;
432 put_bits(&s->pb, 1, s->flipflop_rounding);
436 /* predict coded block */
437 static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
439 int xy, wrap, pred, a, b, c;
441 xy = s->block_index[n];
442 wrap = s->block_wrap[0];
447 a = s->coded_block[xy - 1 ];
448 b = s->coded_block[xy - 1 - wrap];
449 c = s->coded_block[xy - wrap];
458 *coded_block_ptr = &s->coded_block[xy];
463 static void msmpeg4_encode_motion(MpegEncContext * s,
469 /* modulo encoding */
470 /* WARNING : you cannot reach all the MVs even with the modulo
471 encoding. This is a somewhat strange compromise they took !!! */
484 if ((unsigned)mx >= 64 ||
486 fprintf(stderr, "error mx=%d my=%d\n", mx, my);
488 mv = &mv_tables[s->mv_table_index];
490 code = mv->table_mv_index[(mx << 6) | my];
493 mv->table_mv_bits[code],
494 mv->table_mv_code[code]);
496 /* escape : code litterally */
497 put_bits(&s->pb, 6, mx);
498 put_bits(&s->pb, 6, my);
502 static inline void handle_slices(MpegEncContext *s){
504 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
505 if(s->msmpeg4_version < 4){
506 ff_mpeg4_clean_buffers(s);
508 s->first_slice_line = 1;
510 s->first_slice_line = 0;
515 void msmpeg4_encode_mb(MpegEncContext * s,
516 DCTELEM block[6][64],
517 int motion_x, int motion_y)
519 int cbp, coded_cbp, i;
527 set_stat(ST_INTER_MB);
529 for (i = 0; i < 6; i++) {
530 if (s->block_last_index[i] >= 0)
533 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
534 /* skip macroblock */
535 put_bits(&s->pb, 1, 1);
538 if (s->use_skip_mb_code)
539 put_bits(&s->pb, 1, 0); /* mb coded */
541 if(s->msmpeg4_version<=2){
543 v2_mb_type[cbp&3][1],
544 v2_mb_type[cbp&3][0]);
545 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
549 cbpy_tab[coded_cbp>>2][1],
550 cbpy_tab[coded_cbp>>2][0]);
552 h263_pred_motion(s, 0, &pred_x, &pred_y);
553 msmpeg4v2_encode_motion(s, motion_x - pred_x);
554 msmpeg4v2_encode_motion(s, motion_y - pred_y);
557 table_mb_non_intra[cbp + 64][1],
558 table_mb_non_intra[cbp + 64][0]);
561 h263_pred_motion(s, 0, &pred_x, &pred_y);
562 msmpeg4_encode_motion(s, motion_x - pred_x,
569 for (i = 0; i < 6; i++) {
571 val = (s->block_last_index[i] >= 1);
572 cbp |= val << (5 - i);
574 /* predict value for close blocks only for luma */
575 pred = coded_block_pred(s, i, &coded_block);
579 coded_cbp |= val << (5 - i);
583 printf("cbp=%x %x\n", cbp, coded_cbp);
586 if(s->msmpeg4_version<=2){
587 if (s->pict_type == I_TYPE) {
589 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
591 if (s->use_skip_mb_code)
592 put_bits(&s->pb, 1, 0); /* mb coded */
594 v2_mb_type[(cbp&3) + 4][1],
595 v2_mb_type[(cbp&3) + 4][0]);
597 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
600 cbpy_tab[cbp>>2][0]);
602 if (s->pict_type == I_TYPE) {
603 set_stat(ST_INTRA_MB);
605 table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
607 if (s->use_skip_mb_code)
608 put_bits(&s->pb, 1, 0); /* mb coded */
610 table_mb_non_intra[cbp][1],
611 table_mb_non_intra[cbp][0]);
613 set_stat(ST_INTRA_MB);
614 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
615 if(s->inter_intra_pred){
617 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
622 for (i = 0; i < 6; i++) {
623 msmpeg4_encode_block(s, block[i], i);
627 /* old ffmpeg msmpeg4v3 mode */
628 void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
633 }else if (s->qscale < 9){
634 s->y_dc_scale = 2 * s->qscale;
635 s->c_dc_scale = (s->qscale + 13)>>1;
637 s->y_dc_scale = s->qscale + 8;
638 s->c_dc_scale = (s->qscale + 13)>>1;
642 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
653 *dc_val_ptr= &s->last_dc[i];
654 return s->last_dc[i];
657 static int get_dc(uint8_t *src, int stride, int scale)
664 sum+=src[x + y*stride];
667 return (sum + (scale>>1))/scale;
670 /* dir = 0: left, dir = 1: top prediction */
671 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
672 UINT16 **dc_val_ptr, int *dir_ptr)
674 int a, b, c, wrap, pred, scale;
677 /* find prediction */
679 scale = s->y_dc_scale;
681 scale = s->c_dc_scale;
684 wrap = s->block_wrap[n];
685 dc_val= s->dc_val[0] + s->block_index[n];
691 b = dc_val[ - 1 - wrap];
694 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
698 /* XXX: the following solution consumes divisions, but it does not
699 necessitate to modify mpegvideo.c. The problem comes from the
700 fact they decided to store the quantized DC (which would lead
701 to problems if Q could vary !) */
702 #if defined ARCH_X86 && !defined PIC
704 "movl %3, %%eax \n\t"
705 "shrl $1, %%eax \n\t"
706 "addl %%eax, %2 \n\t"
707 "addl %%eax, %1 \n\t"
708 "addl %0, %%eax \n\t"
710 "movl %%edx, %0 \n\t"
711 "movl %1, %%eax \n\t"
713 "movl %%edx, %1 \n\t"
714 "movl %2, %%eax \n\t"
716 "movl %%edx, %2 \n\t"
717 : "+b" (a), "+c" (b), "+D" (c)
718 : "g" (scale), "S" (inverse[scale])
722 /* #elif defined (ARCH_ALPHA) */
723 /* Divisions are extremely costly on Alpha; optimize the most
724 common case. But they are costly everywhere...
727 a = (a + (8 >> 1)) / 8;
728 b = (b + (8 >> 1)) / 8;
729 c = (c + (8 >> 1)) / 8;
731 a = (a + (scale >> 1)) / scale;
732 b = (b + (scale >> 1)) / scale;
733 c = (c + (scale >> 1)) / scale;
736 /* XXX: WARNING: they did not choose the same test as MPEG4. This
737 is very important ! */
738 if(s->msmpeg4_version>3){
739 if(s->inter_intra_pred){
750 if (abs(a - b) < abs(b - c)) {
760 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
763 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
765 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
766 else a= get_dc(dest-8, wrap, scale*8);
767 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
768 else c= get_dc(dest-8*wrap, wrap, scale*8);
770 if (s->h263_aic_dir==0) {
773 }else if (s->h263_aic_dir==1) {
781 }else if (s->h263_aic_dir==2) {
795 if (abs(a - b) < abs(b - c)) {
804 if (abs(a - b) <= abs(b - c)) {
813 /* update predictor */
814 *dc_val_ptr = &dc_val[0];
820 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
825 if(s->msmpeg4_version==1){
827 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
829 /* update predictor */
833 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
835 /* update predictor */
837 *dc_val = level * s->y_dc_scale;
839 *dc_val = level * s->c_dc_scale;
843 /* do the prediction */
846 if(s->msmpeg4_version<=2){
849 v2_dc_lum_table[level+256][1],
850 v2_dc_lum_table[level+256][0]);
853 v2_dc_chroma_table[level+256][1],
854 v2_dc_chroma_table[level+256][0]);
866 if (s->dc_table_index == 0) {
868 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
870 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
874 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
876 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
881 put_bits(&s->pb, 8, level);
884 put_bits(&s->pb, 1, sign);
889 /* Encoding of a block. Very similar to MPEG4 except for a different
890 escape coding (same as H263) and more vlc tables.
892 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
894 int level, run, last, i, j, last_index;
895 int last_non_zero, sign, slevel;
896 int code, run_diff, dc_pred_dir;
898 const UINT8 *scantable;
902 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
905 rl = &rl_table[s->rl_table_index];
907 rl = &rl_table[3 + s->rl_chroma_table_index];
910 scantable= s->intra_scantable.permutated;
911 set_stat(ST_INTRA_AC);
914 rl = &rl_table[3 + s->rl_table_index];
915 if(s->msmpeg4_version<=2)
919 scantable= s->inter_scantable.permutated;
920 set_stat(ST_INTER_AC);
923 /* recalculate block_last_index for M$ wmv1 */
924 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
925 for(last_index=63; last_index>=0; last_index--){
926 if(block[scantable[last_index]]) break;
928 s->block_last_index[n]= last_index;
930 last_index = s->block_last_index[n];
932 last_non_zero = i - 1;
933 for (; i <= last_index; i++) {
937 run = i - last_non_zero - 1;
938 last = (i == last_index);
946 if(level<=MAX_LEVEL && run<=MAX_RUN){
947 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
951 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
953 code = get_rl_index(rl, last, run, level);
954 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
958 level1 = level - rl->max_level[last][run];
961 code = get_rl_index(rl, last, run, level1);
964 put_bits(&s->pb, 1, 0);
965 if (level > MAX_LEVEL)
967 run1 = run - rl->max_run[last][level] - run_diff;
970 code = get_rl_index(rl, last, run1, level);
974 put_bits(&s->pb, 1, 0);
975 put_bits(&s->pb, 1, last);
976 if(s->msmpeg4_version>=4){
977 if(s->esc3_level_length==0){
978 s->esc3_level_length=8;
979 s->esc3_run_length= 6;
981 put_bits(&s->pb, 6, 3);
983 put_bits(&s->pb, 8, 3);
985 put_bits(&s->pb, s->esc3_run_length, run);
986 put_bits(&s->pb, 1, sign);
987 put_bits(&s->pb, s->esc3_level_length, level);
989 put_bits(&s->pb, 6, run);
990 put_bits(&s->pb, 8, slevel & 0xff);
994 put_bits(&s->pb, 1, 1);
995 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
996 put_bits(&s->pb, 1, sign);
1000 put_bits(&s->pb, 1, 1);
1001 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1002 put_bits(&s->pb, 1, sign);
1005 put_bits(&s->pb, 1, sign);
1012 /****************************************/
1013 /* decoding stuff */
1015 static VLC mb_non_intra_vlc[4];
1016 static VLC mb_intra_vlc;
1017 static VLC dc_lum_vlc[2];
1018 static VLC dc_chroma_vlc[2];
1019 static VLC v2_dc_lum_vlc;
1020 static VLC v2_dc_chroma_vlc;
1021 static VLC cbpy_vlc;
1022 static VLC v2_intra_cbpc_vlc;
1023 static VLC v2_mb_type_vlc;
1024 static VLC v2_mv_vlc;
1025 static VLC v1_intra_cbpc_vlc;
1026 static VLC v1_inter_cbpc_vlc;
1027 static VLC inter_intra_vlc;
1029 /* this table is practically identical to the one from h263 except that its inverted */
1030 static void init_h263_dc_for_msmpeg4(void)
1032 int level, uni_code, uni_len;
1034 for(level=-256; level<256; level++){
1036 /* find number of bits */
1045 l= (-level) ^ ((1 << size) - 1);
1049 /* luminance h263 */
1050 uni_code= DCtab_lum[size][0];
1051 uni_len = DCtab_lum[size][1];
1052 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1055 uni_code<<=size; uni_code|=l;
1058 uni_code<<=1; uni_code|=1;
1062 v2_dc_lum_table[level+256][0]= uni_code;
1063 v2_dc_lum_table[level+256][1]= uni_len;
1065 /* chrominance h263 */
1066 uni_code= DCtab_chrom[size][0];
1067 uni_len = DCtab_chrom[size][1];
1068 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1071 uni_code<<=size; uni_code|=l;
1074 uni_code<<=1; uni_code|=1;
1078 v2_dc_chroma_table[level+256][0]= uni_code;
1079 v2_dc_chroma_table[level+256][1]= uni_len;
1084 /* init all vlc decoding tables */
1085 int ff_msmpeg4_decode_init(MpegEncContext *s)
1087 static int done = 0;
1096 for(i=0;i<NB_RL_TABLES;i++) {
1097 init_rl(&rl_table[i]);
1098 init_vlc_rl(&rl_table[i]);
1102 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1103 mv->table_mv_bits, 1, 1,
1104 mv->table_mv_code, 2, 2);
1107 init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120,
1108 &table0_dc_lum[0][1], 8, 4,
1109 &table0_dc_lum[0][0], 8, 4);
1110 init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120,
1111 &table0_dc_chroma[0][1], 8, 4,
1112 &table0_dc_chroma[0][0], 8, 4);
1113 init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120,
1114 &table1_dc_lum[0][1], 8, 4,
1115 &table1_dc_lum[0][0], 8, 4);
1116 init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120,
1117 &table1_dc_chroma[0][1], 8, 4,
1118 &table1_dc_chroma[0][0], 8, 4);
1120 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1121 &v2_dc_lum_table[0][1], 8, 4,
1122 &v2_dc_lum_table[0][0], 8, 4);
1123 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1124 &v2_dc_chroma_table[0][1], 8, 4,
1125 &v2_dc_chroma_table[0][0], 8, 4);
1127 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1128 &cbpy_tab[0][1], 2, 1,
1129 &cbpy_tab[0][0], 2, 1);
1130 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1131 &v2_intra_cbpc[0][1], 2, 1,
1132 &v2_intra_cbpc[0][0], 2, 1);
1133 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1134 &v2_mb_type[0][1], 2, 1,
1135 &v2_mb_type[0][0], 2, 1);
1136 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1138 &mvtab[0][0], 2, 1);
1141 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1142 &wmv2_inter_table[i][0][1], 8, 4,
1143 &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1146 init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,
1147 &table_mb_intra[0][1], 4, 2,
1148 &table_mb_intra[0][0], 4, 2);
1150 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1151 intra_MCBPC_bits, 1, 1,
1152 intra_MCBPC_code, 1, 1);
1153 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1154 inter_MCBPC_bits, 1, 1,
1155 inter_MCBPC_code, 1, 1);
1157 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1158 &table_inter_intra[0][1], 2, 1,
1159 &table_inter_intra[0][0], 2, 1);
1162 switch(s->msmpeg4_version){
1165 s->decode_mb= msmpeg4v12_decode_mb;
1169 s->decode_mb= msmpeg4v34_decode_mb;
1172 s->decode_mb= wmv2_decode_mb;
1176 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1181 static int decode012(GetBitContext *gb)
1188 return get_bits1(gb) + 1;
1191 int msmpeg4_decode_picture_header(MpegEncContext * s)
1198 for(i=0; i<s->gb.size_in_bits; i++)
1199 printf("%d", get_bits1(&s->gb));
1200 // get_bits1(&s->gb);
1206 if(s->msmpeg4_version==1){
1207 int start_code, num;
1208 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1209 if(start_code!=0x00000100){
1210 fprintf(stderr, "invalid startcode\n");
1214 num= get_bits(&s->gb, 5); // frame number */
1217 s->pict_type = get_bits(&s->gb, 2) + 1;
1218 if (s->pict_type != I_TYPE &&
1219 s->pict_type != P_TYPE){
1220 fprintf(stderr, "invalid picture type\n");
1226 if(s->pict_type == I_TYPE) had_i=1;
1227 if(!had_i) return -1;
1230 s->qscale = get_bits(&s->gb, 5);
1232 if (s->pict_type == I_TYPE) {
1233 code = get_bits(&s->gb, 5);
1234 if(s->msmpeg4_version==1){
1235 if(code==0 || code>s->mb_height){
1236 fprintf(stderr, "invalid slice height %d\n", code);
1240 s->slice_height = code;
1242 /* 0x17: one slice, 0x18: two slices, ... */
1244 fprintf(stderr, "error, slice code was %X\n", code);
1248 s->slice_height = s->mb_height / (code - 0x16);
1251 switch(s->msmpeg4_version){
1254 s->rl_chroma_table_index = 2;
1255 s->rl_table_index = 2;
1257 s->dc_table_index = 0; //not used
1260 s->rl_chroma_table_index = decode012(&s->gb);
1261 s->rl_table_index = decode012(&s->gb);
1263 s->dc_table_index = get_bits1(&s->gb);
1266 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1268 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1269 else s->per_mb_rl_table= 0;
1271 if(!s->per_mb_rl_table){
1272 s->rl_chroma_table_index = decode012(&s->gb);
1273 s->rl_table_index = decode012(&s->gb);
1276 s->dc_table_index = get_bits1(&s->gb);
1277 s->inter_intra_pred= 0;
1281 /* printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1283 s->rl_chroma_table_index,
1289 switch(s->msmpeg4_version){
1292 if(s->msmpeg4_version==1)
1293 s->use_skip_mb_code = 1;
1295 s->use_skip_mb_code = get_bits1(&s->gb);
1296 s->rl_table_index = 2;
1297 s->rl_chroma_table_index = s->rl_table_index;
1298 s->dc_table_index = 0; //not used
1299 s->mv_table_index = 0;
1302 s->use_skip_mb_code = get_bits1(&s->gb);
1303 s->rl_table_index = decode012(&s->gb);
1304 s->rl_chroma_table_index = s->rl_table_index;
1306 s->dc_table_index = get_bits1(&s->gb);
1308 s->mv_table_index = get_bits1(&s->gb);
1311 s->use_skip_mb_code = get_bits1(&s->gb);
1313 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1314 else s->per_mb_rl_table= 0;
1316 if(!s->per_mb_rl_table){
1317 s->rl_table_index = decode012(&s->gb);
1318 s->rl_chroma_table_index = s->rl_table_index;
1321 s->dc_table_index = get_bits1(&s->gb);
1323 s->mv_table_index = get_bits1(&s->gb);
1324 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1327 /* printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1328 s->use_skip_mb_code,
1330 s->rl_chroma_table_index,
1335 if(s->flipflop_rounding){
1336 s->no_rounding ^= 1;
1341 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1343 s->esc3_level_length= 0;
1344 s->esc3_run_length= 0;
1347 printf("*****frame %d:\n", frame_count++);
1352 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1354 int left= buf_size*8 - get_bits_count(&s->gb);
1355 int length= s->msmpeg4_version>=3 ? 17 : 16;
1356 /* the alt_bitstream reader could read over the end so we need to check it */
1357 if(left>=length && left<length+8)
1361 fps= get_bits(&s->gb, 5);
1362 s->bit_rate= get_bits(&s->gb, 11)*1024;
1363 if(s->msmpeg4_version>=3)
1364 s->flipflop_rounding= get_bits1(&s->gb);
1366 s->flipflop_rounding= 0;
1368 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1370 else if(left<length+8)
1372 s->flipflop_rounding= 0;
1373 printf("ext header missing, %d left\n", left);
1377 fprintf(stderr, "I frame too long, ignoring ext header\n");
1383 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1390 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1392 int range, bit_size, sign, code, bits;
1397 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1399 bit_size = s->f_code - 1;
1400 range = 1 << bit_size;
1413 code = (val >> bit_size) + 1;
1414 bits = val & (range - 1);
1416 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1418 put_bits(&s->pb, bit_size, bits);
1423 /* this is identical to h263 except that its range is multiplied by 2 */
1424 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1426 int code, val, sign, shift;
1428 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1429 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1435 sign = get_bits1(&s->gb);
1437 val = (code - 1) << shift;
1439 val |= get_bits(&s->gb, shift);
1453 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1457 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1459 if (s->pict_type == P_TYPE) {
1460 if (s->use_skip_mb_code) {
1461 if (get_bits1(&s->gb)) {
1465 s->block_last_index[i] = -1;
1466 s->mv_dir = MV_DIR_FORWARD;
1467 s->mv_type = MV_TYPE_16X16;
1475 if(s->msmpeg4_version==2)
1476 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1478 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1479 if(code<0 || code>7){
1480 fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1484 s->mb_intra = code >>2;
1489 if(s->msmpeg4_version==2)
1490 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1492 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1494 fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1502 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1504 fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1509 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1511 h263_pred_motion(s, 0, &mx, &my);
1512 mx= msmpeg4v2_decode_motion(s, mx, 1);
1513 my= msmpeg4v2_decode_motion(s, my, 1);
1515 s->mv_dir = MV_DIR_FORWARD;
1516 s->mv_type = MV_TYPE_16X16;
1517 s->mv[0][0][0] = mx;
1518 s->mv[0][0][1] = my;
1520 if(s->msmpeg4_version==2){
1521 s->ac_pred = get_bits1(&s->gb);
1522 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1525 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1526 if(s->pict_type==P_TYPE) cbp^=0x3C;
1530 for (i = 0; i < 6; i++) {
1531 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1533 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1540 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1548 if(s->mb_y==0) printf("\n");
1552 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1554 if (s->pict_type == P_TYPE) {
1555 set_stat(ST_INTER_MB);
1556 if (s->use_skip_mb_code) {
1557 if (get_bits1(&s->gb)) {
1561 s->block_last_index[i] = -1;
1562 s->mv_dir = MV_DIR_FORWARD;
1563 s->mv_type = MV_TYPE_16X16;
1574 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1577 //s->mb_intra = (code & 0x40) ? 0 : 1;
1578 s->mb_intra = (~code & 0x40) >> 6;
1582 set_stat(ST_INTRA_MB);
1584 code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1587 /* predict coded block pattern */
1590 int val = ((code >> (5 - i)) & 1);
1592 int pred = coded_block_pred(s, i, &coded_val);
1596 cbp |= val << (5 - i);
1602 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1603 if(s->per_mb_rl_table && cbp){
1604 s->rl_table_index = decode012(&s->gb);
1605 s->rl_chroma_table_index = s->rl_table_index;
1608 h263_pred_motion(s, 0, &mx, &my);
1609 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1611 s->mv_dir = MV_DIR_FORWARD;
1612 s->mv_type = MV_TYPE_16X16;
1613 s->mv[0][0][0] = mx;
1614 s->mv[0][0][1] = my;
1619 //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));
1620 set_stat(ST_INTRA_MB);
1621 s->ac_pred = get_bits1(&s->gb);
1623 printf("%c", s->ac_pred ? 'A' : 'I');
1625 if(s->inter_intra_pred){
1626 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1627 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1629 if(s->per_mb_rl_table && cbp){
1630 s->rl_table_index = decode012(&s->gb);
1631 s->rl_chroma_table_index = s->rl_table_index;
1635 for (i = 0; i < 6; i++) {
1636 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1638 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1645 //#define ERROR_DETAILS
1646 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1647 int n, int coded, const uint8_t *scan_table)
1649 int level, i, last, run, run_diff;
1652 RL_VLC_ELEM *rl_vlc;
1661 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1666 if(n==4) printf("%X", c);
1671 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1672 if(s->inter_intra_pred) level=0;
1676 rl = &rl_table[s->rl_table_index];
1677 if(level > 256*s->y_dc_scale){
1678 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1679 if(!s->inter_intra_pred) return -1;
1682 rl = &rl_table[3 + s->rl_chroma_table_index];
1683 if(level > 256*s->c_dc_scale){
1684 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1685 if(!s->inter_intra_pred) return -1;
1696 if (dc_pred_dir == 0)
1697 scan_table = s->intra_v_scantable.permutated; /* left */
1699 scan_table = s->intra_h_scantable.permutated; /* top */
1701 scan_table = s->intra_scantable.permutated;
1703 set_stat(ST_INTRA_AC);
1704 rl_vlc= rl->rl_vlc[0];
1706 qmul = s->qscale << 1;
1707 qadd = (s->qscale - 1) | 1;
1709 rl = &rl_table[3 + s->rl_table_index];
1711 if(s->msmpeg4_version==2)
1717 s->block_last_index[n] = i;
1721 scan_table = s->inter_scantable.permutated;
1722 set_stat(ST_INTER_AC);
1723 rl_vlc= rl->rl_vlc[s->qscale];
1726 OPEN_READER(re, &s->gb);
1728 UPDATE_CACHE(re, &s->gb);
1729 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1732 cache= GET_CACHE(re, &s->gb);
1734 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1735 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1737 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1738 UPDATE_CACHE(re, &s->gb);
1739 if(s->msmpeg4_version<=3){
1740 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1741 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1742 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1743 SKIP_COUNTER(re, &s->gb, 1+6+8);
1746 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1747 if(!s->esc3_level_length){
1749 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1751 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1753 if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1754 SKIP_BITS(re, &s->gb, 1);
1759 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1761 SKIP_BITS(re, &s->gb, 1);
1763 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1766 s->esc3_level_length= ll;
1767 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1768 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1769 UPDATE_CACHE(re, &s->gb);
1771 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1772 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1774 sign= SHOW_UBITS(re, &s->gb, 1);
1775 SKIP_BITS(re, &s->gb, 1);
1777 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1778 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1779 if(sign) level= -level;
1781 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1782 #if 0 // waste of time / this will detect very few errors
1784 const int abs_level= ABS(level);
1785 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1786 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1787 if(abs_level <= rl->max_level[last][run]){
1788 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1789 return DECODING_AC_LOST;
1791 if(abs_level <= rl->max_level[last][run]*2){
1792 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1793 return DECODING_AC_LOST;
1795 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1796 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1797 return DECODING_AC_LOST;
1802 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1803 if (level>0) level= level * qmul + qadd;
1804 else level= level * qmul - qadd;
1805 #if 0 // waste of time too :(
1806 if(level>2048 || level<-2048){
1807 fprintf(stderr, "|level| overflow in 3. esc\n");
1808 return DECODING_AC_LOST;
1813 #ifdef ERROR_DETAILS
1815 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1816 else if((i>62 && i<192) || i>192+63)
1817 fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1821 #if MIN_CACHE_BITS < 23
1822 LAST_SKIP_BITS(re, &s->gb, 2);
1823 UPDATE_CACHE(re, &s->gb);
1825 SKIP_BITS(re, &s->gb, 2);
1827 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1828 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1829 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1830 LAST_SKIP_BITS(re, &s->gb, 1);
1831 #ifdef ERROR_DETAILS
1833 fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1834 else if((i>62 && i<192) || i>192+63)
1835 fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1840 #if MIN_CACHE_BITS < 22
1841 LAST_SKIP_BITS(re, &s->gb, 1);
1842 UPDATE_CACHE(re, &s->gb);
1844 SKIP_BITS(re, &s->gb, 1);
1846 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1848 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1849 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1850 LAST_SKIP_BITS(re, &s->gb, 1);
1851 #ifdef ERROR_DETAILS
1853 fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1854 else if((i>62 && i<192) || i>192+63)
1855 fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1860 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1861 LAST_SKIP_BITS(re, &s->gb, 1);
1862 #ifdef ERROR_DETAILS
1864 fprintf(stderr, "illegal vlc code level=%d\n", level);
1865 else if((i>62 && i<192) || i>192+63)
1866 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1872 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1873 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1874 fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1877 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1882 block[scan_table[i]] = level;
1886 block[scan_table[i]] = level;
1888 CLOSE_READER(re, &s->gb);
1892 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1894 i = 63; /* XXX: not optimal */
1897 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1898 s->block_last_index[n] = i;
1903 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1907 if(s->msmpeg4_version<=2){
1909 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1911 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1916 }else{ //FIXME optimize use unified tables & index
1918 level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1920 level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1923 fprintf(stderr, "illegal dc vlc\n");
1927 if (level == DC_MAX) {
1928 level = get_bits(&s->gb, 8);
1929 if (get_bits1(&s->gb))
1931 } else if (level != 0) {
1932 if (get_bits1(&s->gb))
1937 if(s->msmpeg4_version==1){
1939 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1942 /* update predictor */
1946 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1949 /* update predictor */
1951 *dc_val = level * s->y_dc_scale;
1953 *dc_val = level * s->c_dc_scale;
1960 static int msmpeg4_decode_motion(MpegEncContext * s,
1961 int *mx_ptr, int *my_ptr)
1966 mv = &mv_tables[s->mv_table_index];
1968 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1970 fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1973 if (code == mv->n) {
1974 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1975 mx = get_bits(&s->gb, 6);
1976 my = get_bits(&s->gb, 6);
1978 mx = mv->table_mvx[code];
1979 my = mv->table_mvy[code];
1984 /* WARNING : they do not do exactly modulo encoding */
1999 /* cleanest way to support it
2000 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2001 * as allmost everything would be in the common file