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>
24 * MSMPEG4 backend for ffmpeg encoder and decoder.
29 #include "mpegvideo.h"
32 * You can also call this codec : MPEG4 with a twist !
35 * - (encoding) select best mv table (two choices)
36 * - (encoding) select best vlc/dc table
41 #define CBPY_VLC_BITS 6
42 #define INTER_INTRA_VLC_BITS 3
43 #define V1_INTRA_CBPC_VLC_BITS 6
44 #define V1_INTER_CBPC_VLC_BITS 6
45 #define V2_INTRA_CBPC_VLC_BITS 3
46 #define V2_MB_TYPE_VLC_BITS 7
48 #define V2_MV_VLC_BITS 9
49 #define TEX_VLC_BITS 9
50 #define MB_NON_INTRA_VLC_BITS 9
51 #define MB_INTRA_VLC_BITS 9
53 #define II_BITRATE 128*1024
54 #define MBAC_BITRATE 50*1024
56 #define DEFAULT_INTER_INDEX 3
58 static uint32_t v2_dc_lum_table[512][2];
59 static uint32_t v2_dc_chroma_table[512][2];
61 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
62 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
63 int n, int coded, const uint8_t *scantable);
64 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
65 static int msmpeg4_decode_motion(MpegEncContext * s,
66 int *mx_ptr, int *my_ptr);
67 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
68 static void init_h263_dc_for_msmpeg4(void);
69 static inline void msmpeg4_memsetw(short *tab, int val, int n);
70 #ifdef CONFIG_ENCODERS
71 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
72 #endif //CONFIG_ENCODERS
73 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
74 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
83 #include "msmpeg4data.h"
85 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
86 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
87 #endif //CONFIG_ENCODERS
91 const char *st_names[ST_NB] = {
101 int st_current_index = 0;
102 unsigned int st_bit_counts[ST_NB];
103 unsigned int st_out_bit_counts[ST_NB];
105 #define set_stat(var) st_current_index = var;
107 void print_stats(void)
115 total += st_bit_counts[i];
118 for(i=0;i<ST_NB;i++) {
119 printf("%-10s : %10.1f %5.1f%%\n",
121 (double)st_bit_counts[i] / 8.0,
122 (double)st_bit_counts[i] * 100.0 / total);
124 printf("%-10s : %10.1f %5.1f%%\n",
132 total += st_out_bit_counts[i];
135 for(i=0;i<ST_NB;i++) {
136 printf("%-10s : %10.1f %5.1f%%\n",
138 (double)st_out_bit_counts[i] / 8.0,
139 (double)st_out_bit_counts[i] * 100.0 / total);
141 printf("%-10s : %10.1f %5.1f%%\n",
149 #define set_stat(var)
153 static void common_init(MpegEncContext * s)
157 switch(s->msmpeg4_version){
161 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
164 if(s->workaround_bugs){
165 s->y_dc_scale_table= old_ff_y_dc_scale_table;
166 s->c_dc_scale_table= old_ff_c_dc_scale_table;
168 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
169 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
174 s->y_dc_scale_table= wmv1_y_dc_scale_table;
175 s->c_dc_scale_table= wmv1_c_dc_scale_table;
180 if(s->msmpeg4_version>=4){
181 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
182 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
183 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
184 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
186 //Note the default tables are set in common_init in mpegvideo.c
191 init_h263_dc_for_msmpeg4();
195 #ifdef CONFIG_ENCODERS
197 /* build the table which associate a (x,y) motion vector to a vlc */
198 static void init_mv_table(MVTable *tab)
202 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
203 /* mark all entries as not used */
205 tab->table_mv_index[i] = tab->n;
207 for(i=0;i<tab->n;i++) {
208 x = tab->table_mvx[i];
209 y = tab->table_mvy[i];
210 tab->table_mv_index[(x << 6) | y] = i;
214 static void code012(PutBitContext *pb, int n)
220 put_bits(pb, 1, (n >= 2));
224 void ff_msmpeg4_encode_init(MpegEncContext *s)
226 static int init_done=0;
230 if(s->msmpeg4_version>=4){
236 /* init various encoding tables */
238 init_mv_table(&mv_tables[0]);
239 init_mv_table(&mv_tables[1]);
240 for(i=0;i<NB_RL_TABLES;i++)
241 init_rl(&rl_table[i]);
243 for(i=0; i<NB_RL_TABLES; i++){
245 for(level=0; level<=MAX_LEVEL; level++){
247 for(run=0; run<=MAX_RUN; run++){
249 for(last=0; last<2; last++){
250 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
258 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
261 int run_diff= intra ? 0 : 1;
263 code = get_rl_index(rl, last, run, level);
264 size+= rl->table_vlc[code][1];
268 level1 = level - rl->max_level[last][run];
271 code = get_rl_index(rl, last, run, level1);
275 if (level > MAX_LEVEL)
277 run1 = run - rl->max_run[last][level] - run_diff;
280 code = get_rl_index(rl, last, run1, level);
287 size+= 1+1+ rl->table_vlc[code][1];
291 size+= 1+1+ rl->table_vlc[code][1];
299 static void find_best_tables(MpegEncContext * s)
302 int best =-1, best_size =9999999;
303 int chroma_best=-1, best_chroma_size=9999999;
314 for(level=0; level<=MAX_LEVEL; level++){
316 for(run=0; run<=MAX_RUN; run++){
318 const int last_size= size + chroma_size;
319 for(last=0; last<2; last++){
320 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
321 int intra_luma_count = s->ac_stats[1][0][level][run][last];
322 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
324 if(s->pict_type==I_TYPE){
325 size += intra_luma_count *rl_length[i ][level][run][last];
326 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
328 size+= intra_luma_count *rl_length[i ][level][run][last]
329 +intra_chroma_count*rl_length[i+3][level][run][last]
330 +inter_count *rl_length[i+3][level][run][last];
333 if(last_size == size+chroma_size) break;
340 if(chroma_size<best_chroma_size){
341 best_chroma_size= chroma_size;
346 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
347 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
349 if(s->pict_type==P_TYPE) chroma_best= best;
351 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
353 s->rl_table_index = best;
354 s->rl_chroma_table_index= chroma_best;
356 if(s->pict_type != s->last_non_b_pict_type){
357 s->rl_table_index= 2;
358 if(s->pict_type==I_TYPE)
359 s->rl_chroma_table_index= 1;
361 s->rl_chroma_table_index= 2;
366 /* write MSMPEG4 compatible frame header */
367 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
371 align_put_bits(&s->pb);
372 put_bits(&s->pb, 2, s->pict_type - 1);
374 put_bits(&s->pb, 5, s->qscale);
375 if(s->msmpeg4_version<=2){
376 s->rl_table_index = 2;
377 s->rl_chroma_table_index = 2;
380 s->dc_table_index = 1;
381 s->mv_table_index = 1; /* only if P frame */
382 s->use_skip_mb_code = 1; /* only if P frame */
383 s->per_mb_rl_table = 0;
384 if(s->msmpeg4_version==4)
385 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
386 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
388 if (s->pict_type == I_TYPE) {
389 s->slice_height= s->mb_height/1;
390 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
392 if(s->msmpeg4_version==4){
393 msmpeg4_encode_ext_header(s);
394 if(s->bit_rate>MBAC_BITRATE)
395 put_bits(&s->pb, 1, s->per_mb_rl_table);
398 if(s->msmpeg4_version>2){
399 if(!s->per_mb_rl_table){
400 code012(&s->pb, s->rl_chroma_table_index);
401 code012(&s->pb, s->rl_table_index);
404 put_bits(&s->pb, 1, s->dc_table_index);
407 put_bits(&s->pb, 1, s->use_skip_mb_code);
409 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
410 put_bits(&s->pb, 1, s->per_mb_rl_table);
412 if(s->msmpeg4_version>2){
413 if(!s->per_mb_rl_table)
414 code012(&s->pb, s->rl_table_index);
416 put_bits(&s->pb, 1, s->dc_table_index);
418 put_bits(&s->pb, 1, s->mv_table_index);
422 s->esc3_level_length= 0;
423 s->esc3_run_length= 0;
427 printf("*****frame %d:\n", frame_count++);
431 void msmpeg4_encode_ext_header(MpegEncContext * s)
433 put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
435 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
437 if(s->msmpeg4_version>=3)
438 put_bits(&s->pb, 1, s->flipflop_rounding);
440 assert(s->flipflop_rounding==0);
443 #endif //CONFIG_ENCODERS
445 /* predict coded block */
446 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
448 int xy, wrap, pred, a, b, c;
450 xy = s->block_index[n];
451 wrap = s->block_wrap[0];
456 a = s->coded_block[xy - 1 ];
457 b = s->coded_block[xy - 1 - wrap];
458 c = s->coded_block[xy - wrap];
467 *coded_block_ptr = &s->coded_block[xy];
472 #ifdef CONFIG_ENCODERS
474 static void msmpeg4_encode_motion(MpegEncContext * s,
480 /* modulo encoding */
481 /* WARNING : you cannot reach all the MVs even with the modulo
482 encoding. This is a somewhat strange compromise they took !!! */
495 if ((unsigned)mx >= 64 ||
497 fprintf(stderr, "error mx=%d my=%d\n", mx, my);
499 mv = &mv_tables[s->mv_table_index];
501 code = mv->table_mv_index[(mx << 6) | my];
504 mv->table_mv_bits[code],
505 mv->table_mv_code[code]);
507 /* escape : code litterally */
508 put_bits(&s->pb, 6, mx);
509 put_bits(&s->pb, 6, my);
513 static inline void handle_slices(MpegEncContext *s){
515 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
516 if(s->msmpeg4_version < 4){
517 ff_mpeg4_clean_buffers(s);
519 s->first_slice_line = 1;
521 s->first_slice_line = 0;
526 void msmpeg4_encode_mb(MpegEncContext * s,
527 DCTELEM block[6][64],
528 int motion_x, int motion_y)
530 int cbp, coded_cbp, i;
532 uint8_t *coded_block;
538 set_stat(ST_INTER_MB);
540 for (i = 0; i < 6; i++) {
541 if (s->block_last_index[i] >= 0)
544 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
545 /* skip macroblock */
546 put_bits(&s->pb, 1, 1);
553 if (s->use_skip_mb_code)
554 put_bits(&s->pb, 1, 0); /* mb coded */
556 if(s->msmpeg4_version<=2){
558 v2_mb_type[cbp&3][1],
559 v2_mb_type[cbp&3][0]);
560 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
564 cbpy_tab[coded_cbp>>2][1],
565 cbpy_tab[coded_cbp>>2][0]);
567 s->misc_bits += get_bits_diff(s);
569 h263_pred_motion(s, 0, &pred_x, &pred_y);
570 msmpeg4v2_encode_motion(s, motion_x - pred_x);
571 msmpeg4v2_encode_motion(s, motion_y - pred_y);
574 table_mb_non_intra[cbp + 64][1],
575 table_mb_non_intra[cbp + 64][0]);
577 s->misc_bits += get_bits_diff(s);
580 h263_pred_motion(s, 0, &pred_x, &pred_y);
581 msmpeg4_encode_motion(s, motion_x - pred_x,
585 s->mv_bits += get_bits_diff(s);
587 for (i = 0; i < 6; i++) {
588 msmpeg4_encode_block(s, block[i], i);
590 s->p_tex_bits += get_bits_diff(s);
595 for (i = 0; i < 6; i++) {
597 val = (s->block_last_index[i] >= 1);
598 cbp |= val << (5 - i);
600 /* predict value for close blocks only for luma */
601 pred = coded_block_pred(s, i, &coded_block);
605 coded_cbp |= val << (5 - i);
609 printf("cbp=%x %x\n", cbp, coded_cbp);
612 if(s->msmpeg4_version<=2){
613 if (s->pict_type == I_TYPE) {
615 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
617 if (s->use_skip_mb_code)
618 put_bits(&s->pb, 1, 0); /* mb coded */
620 v2_mb_type[(cbp&3) + 4][1],
621 v2_mb_type[(cbp&3) + 4][0]);
623 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
626 cbpy_tab[cbp>>2][0]);
628 if (s->pict_type == I_TYPE) {
629 set_stat(ST_INTRA_MB);
631 table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
633 if (s->use_skip_mb_code)
634 put_bits(&s->pb, 1, 0); /* mb coded */
636 table_mb_non_intra[cbp][1],
637 table_mb_non_intra[cbp][0]);
639 set_stat(ST_INTRA_MB);
640 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
641 if(s->inter_intra_pred){
643 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
646 s->misc_bits += get_bits_diff(s);
648 for (i = 0; i < 6; i++) {
649 msmpeg4_encode_block(s, block[i], i);
651 s->i_tex_bits += get_bits_diff(s);
656 #endif //CONFIG_ENCODERS
658 /* old ffmpeg msmpeg4v3 mode */
659 static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
664 }else if (s->qscale < 9){
665 s->y_dc_scale = 2 * s->qscale;
666 s->c_dc_scale = (s->qscale + 13)>>1;
668 s->y_dc_scale = s->qscale + 8;
669 s->c_dc_scale = (s->qscale + 13)>>1;
673 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
674 int32_t **dc_val_ptr)
684 *dc_val_ptr= &s->last_dc[i];
685 return s->last_dc[i];
688 static int get_dc(uint8_t *src, int stride, int scale)
695 sum+=src[x + y*stride];
698 return FASTDIV((sum + (scale>>1)), scale);
701 /* dir = 0: left, dir = 1: top prediction */
702 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
703 uint16_t **dc_val_ptr, int *dir_ptr)
705 int a, b, c, wrap, pred, scale;
708 /* find prediction */
710 scale = s->y_dc_scale;
712 scale = s->c_dc_scale;
715 wrap = s->block_wrap[n];
716 dc_val= s->dc_val[0] + s->block_index[n];
722 b = dc_val[ - 1 - wrap];
725 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
729 /* XXX: the following solution consumes divisions, but it does not
730 necessitate to modify mpegvideo.c. The problem comes from the
731 fact they decided to store the quantized DC (which would lead
732 to problems if Q could vary !) */
733 #if defined ARCH_X86 && !defined PIC
735 "movl %3, %%eax \n\t"
736 "shrl $1, %%eax \n\t"
737 "addl %%eax, %2 \n\t"
738 "addl %%eax, %1 \n\t"
739 "addl %0, %%eax \n\t"
741 "movl %%edx, %0 \n\t"
742 "movl %1, %%eax \n\t"
744 "movl %%edx, %1 \n\t"
745 "movl %2, %%eax \n\t"
747 "movl %%edx, %2 \n\t"
748 : "+b" (a), "+c" (b), "+D" (c)
749 : "g" (scale), "S" (inverse[scale])
753 /* #elif defined (ARCH_ALPHA) */
754 /* Divisions are extremely costly on Alpha; optimize the most
755 common case. But they are costly everywhere...
758 a = (a + (8 >> 1)) / 8;
759 b = (b + (8 >> 1)) / 8;
760 c = (c + (8 >> 1)) / 8;
762 a = FASTDIV((a + (scale >> 1)), scale);
763 b = FASTDIV((b + (scale >> 1)), scale);
764 c = FASTDIV((c + (scale >> 1)), scale);
767 /* XXX: WARNING: they did not choose the same test as MPEG4. This
768 is very important ! */
769 if(s->msmpeg4_version>3){
770 if(s->inter_intra_pred){
781 if (abs(a - b) < abs(b - c)) {
791 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
794 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
796 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
797 else a= get_dc(dest-8, wrap, scale*8);
798 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
799 else c= get_dc(dest-8*wrap, wrap, scale*8);
801 if (s->h263_aic_dir==0) {
804 }else if (s->h263_aic_dir==1) {
812 }else if (s->h263_aic_dir==2) {
826 if (abs(a - b) < abs(b - c)) {
835 if (abs(a - b) <= abs(b - c)) {
844 /* update predictor */
845 *dc_val_ptr = &dc_val[0];
851 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
856 if(s->msmpeg4_version==1){
858 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
860 /* update predictor */
864 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
866 /* update predictor */
868 *dc_val = level * s->y_dc_scale;
870 *dc_val = level * s->c_dc_scale;
874 /* do the prediction */
877 if(s->msmpeg4_version<=2){
880 v2_dc_lum_table[level+256][1],
881 v2_dc_lum_table[level+256][0]);
884 v2_dc_chroma_table[level+256][1],
885 v2_dc_chroma_table[level+256][0]);
897 if (s->dc_table_index == 0) {
899 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
901 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
905 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
907 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
912 put_bits(&s->pb, 8, level);
915 put_bits(&s->pb, 1, sign);
920 /* Encoding of a block. Very similar to MPEG4 except for a different
921 escape coding (same as H263) and more vlc tables.
923 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
925 int level, run, last, i, j, last_index;
926 int last_non_zero, sign, slevel;
927 int code, run_diff, dc_pred_dir;
929 const uint8_t *scantable;
933 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
936 rl = &rl_table[s->rl_table_index];
938 rl = &rl_table[3 + s->rl_chroma_table_index];
941 scantable= s->intra_scantable.permutated;
942 set_stat(ST_INTRA_AC);
945 rl = &rl_table[3 + s->rl_table_index];
946 if(s->msmpeg4_version<=2)
950 scantable= s->inter_scantable.permutated;
951 set_stat(ST_INTER_AC);
954 /* recalculate block_last_index for M$ wmv1 */
955 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
956 for(last_index=63; last_index>=0; last_index--){
957 if(block[scantable[last_index]]) break;
959 s->block_last_index[n]= last_index;
961 last_index = s->block_last_index[n];
963 last_non_zero = i - 1;
964 for (; i <= last_index; i++) {
968 run = i - last_non_zero - 1;
969 last = (i == last_index);
977 if(level<=MAX_LEVEL && run<=MAX_RUN){
978 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
982 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
984 code = get_rl_index(rl, last, run, level);
985 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
989 level1 = level - rl->max_level[last][run];
992 code = get_rl_index(rl, last, run, level1);
995 put_bits(&s->pb, 1, 0);
996 if (level > MAX_LEVEL)
998 run1 = run - rl->max_run[last][level] - run_diff;
1001 code = get_rl_index(rl, last, run1, level);
1002 if (code == rl->n) {
1005 put_bits(&s->pb, 1, 0);
1006 put_bits(&s->pb, 1, last);
1007 if(s->msmpeg4_version>=4){
1008 if(s->esc3_level_length==0){
1009 s->esc3_level_length=8;
1010 s->esc3_run_length= 6;
1012 put_bits(&s->pb, 6, 3);
1014 put_bits(&s->pb, 8, 3);
1016 put_bits(&s->pb, s->esc3_run_length, run);
1017 put_bits(&s->pb, 1, sign);
1018 put_bits(&s->pb, s->esc3_level_length, level);
1020 put_bits(&s->pb, 6, run);
1021 put_bits(&s->pb, 8, slevel & 0xff);
1025 put_bits(&s->pb, 1, 1);
1026 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1027 put_bits(&s->pb, 1, sign);
1031 put_bits(&s->pb, 1, 1);
1032 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1033 put_bits(&s->pb, 1, sign);
1036 put_bits(&s->pb, 1, sign);
1043 /****************************************/
1044 /* decoding stuff */
1046 static VLC mb_non_intra_vlc[4];
1047 static VLC mb_intra_vlc;
1048 static VLC dc_lum_vlc[2];
1049 static VLC dc_chroma_vlc[2];
1050 static VLC v2_dc_lum_vlc;
1051 static VLC v2_dc_chroma_vlc;
1052 static VLC cbpy_vlc;
1053 static VLC v2_intra_cbpc_vlc;
1054 static VLC v2_mb_type_vlc;
1055 static VLC v2_mv_vlc;
1056 static VLC v1_intra_cbpc_vlc;
1057 static VLC v1_inter_cbpc_vlc;
1058 static VLC inter_intra_vlc;
1060 /* this table is practically identical to the one from h263 except that its inverted */
1061 static void init_h263_dc_for_msmpeg4(void)
1063 int level, uni_code, uni_len;
1065 for(level=-256; level<256; level++){
1067 /* find number of bits */
1076 l= (-level) ^ ((1 << size) - 1);
1080 /* luminance h263 */
1081 uni_code= DCtab_lum[size][0];
1082 uni_len = DCtab_lum[size][1];
1083 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1086 uni_code<<=size; uni_code|=l;
1089 uni_code<<=1; uni_code|=1;
1093 v2_dc_lum_table[level+256][0]= uni_code;
1094 v2_dc_lum_table[level+256][1]= uni_len;
1096 /* chrominance h263 */
1097 uni_code= DCtab_chrom[size][0];
1098 uni_len = DCtab_chrom[size][1];
1099 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1102 uni_code<<=size; uni_code|=l;
1105 uni_code<<=1; uni_code|=1;
1109 v2_dc_chroma_table[level+256][0]= uni_code;
1110 v2_dc_chroma_table[level+256][1]= uni_len;
1115 /* init all vlc decoding tables */
1116 int ff_msmpeg4_decode_init(MpegEncContext *s)
1118 static int done = 0;
1127 for(i=0;i<NB_RL_TABLES;i++) {
1128 init_rl(&rl_table[i]);
1129 init_vlc_rl(&rl_table[i]);
1133 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1134 mv->table_mv_bits, 1, 1,
1135 mv->table_mv_code, 2, 2);
1138 init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120,
1139 &table0_dc_lum[0][1], 8, 4,
1140 &table0_dc_lum[0][0], 8, 4);
1141 init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120,
1142 &table0_dc_chroma[0][1], 8, 4,
1143 &table0_dc_chroma[0][0], 8, 4);
1144 init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120,
1145 &table1_dc_lum[0][1], 8, 4,
1146 &table1_dc_lum[0][0], 8, 4);
1147 init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120,
1148 &table1_dc_chroma[0][1], 8, 4,
1149 &table1_dc_chroma[0][0], 8, 4);
1151 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1152 &v2_dc_lum_table[0][1], 8, 4,
1153 &v2_dc_lum_table[0][0], 8, 4);
1154 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1155 &v2_dc_chroma_table[0][1], 8, 4,
1156 &v2_dc_chroma_table[0][0], 8, 4);
1158 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1159 &cbpy_tab[0][1], 2, 1,
1160 &cbpy_tab[0][0], 2, 1);
1161 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1162 &v2_intra_cbpc[0][1], 2, 1,
1163 &v2_intra_cbpc[0][0], 2, 1);
1164 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1165 &v2_mb_type[0][1], 2, 1,
1166 &v2_mb_type[0][0], 2, 1);
1167 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1169 &mvtab[0][0], 2, 1);
1172 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1173 &wmv2_inter_table[i][0][1], 8, 4,
1174 &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1177 init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,
1178 &table_mb_intra[0][1], 4, 2,
1179 &table_mb_intra[0][0], 4, 2);
1181 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1182 intra_MCBPC_bits, 1, 1,
1183 intra_MCBPC_code, 1, 1);
1184 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1185 inter_MCBPC_bits, 1, 1,
1186 inter_MCBPC_code, 1, 1);
1188 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1189 &table_inter_intra[0][1], 2, 1,
1190 &table_inter_intra[0][0], 2, 1);
1193 switch(s->msmpeg4_version){
1196 s->decode_mb= msmpeg4v12_decode_mb;
1200 s->decode_mb= msmpeg4v34_decode_mb;
1203 s->decode_mb= wmv2_decode_mb;
1207 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1212 static int decode012(GetBitContext *gb)
1219 return get_bits1(gb) + 1;
1222 int msmpeg4_decode_picture_header(MpegEncContext * s)
1229 for(i=0; i<s->gb.size_in_bits; i++)
1230 printf("%d", get_bits1(&s->gb));
1231 // get_bits1(&s->gb);
1237 if(s->msmpeg4_version==1){
1238 int start_code, num;
1239 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1240 if(start_code!=0x00000100){
1241 fprintf(stderr, "invalid startcode\n");
1245 num= get_bits(&s->gb, 5); // frame number */
1248 s->pict_type = get_bits(&s->gb, 2) + 1;
1249 if (s->pict_type != I_TYPE &&
1250 s->pict_type != P_TYPE){
1251 fprintf(stderr, "invalid picture type\n");
1257 if(s->pict_type == I_TYPE) had_i=1;
1258 if(!had_i) return -1;
1261 s->qscale = get_bits(&s->gb, 5);
1263 fprintf(stderr, "invalid qscale\n");
1267 if (s->pict_type == I_TYPE) {
1268 code = get_bits(&s->gb, 5);
1269 if(s->msmpeg4_version==1){
1270 if(code==0 || code>s->mb_height){
1271 fprintf(stderr, "invalid slice height %d\n", code);
1275 s->slice_height = code;
1277 /* 0x17: one slice, 0x18: two slices, ... */
1279 fprintf(stderr, "error, slice code was %X\n", code);
1283 s->slice_height = s->mb_height / (code - 0x16);
1286 switch(s->msmpeg4_version){
1289 s->rl_chroma_table_index = 2;
1290 s->rl_table_index = 2;
1292 s->dc_table_index = 0; //not used
1295 s->rl_chroma_table_index = decode012(&s->gb);
1296 s->rl_table_index = decode012(&s->gb);
1298 s->dc_table_index = get_bits1(&s->gb);
1301 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1303 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1304 else s->per_mb_rl_table= 0;
1306 if(!s->per_mb_rl_table){
1307 s->rl_chroma_table_index = decode012(&s->gb);
1308 s->rl_table_index = decode012(&s->gb);
1311 s->dc_table_index = get_bits1(&s->gb);
1312 s->inter_intra_pred= 0;
1316 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1317 printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1319 s->rl_chroma_table_index,
1325 switch(s->msmpeg4_version){
1328 if(s->msmpeg4_version==1)
1329 s->use_skip_mb_code = 1;
1331 s->use_skip_mb_code = get_bits1(&s->gb);
1332 s->rl_table_index = 2;
1333 s->rl_chroma_table_index = s->rl_table_index;
1334 s->dc_table_index = 0; //not used
1335 s->mv_table_index = 0;
1338 s->use_skip_mb_code = get_bits1(&s->gb);
1339 s->rl_table_index = decode012(&s->gb);
1340 s->rl_chroma_table_index = s->rl_table_index;
1342 s->dc_table_index = get_bits1(&s->gb);
1344 s->mv_table_index = get_bits1(&s->gb);
1347 s->use_skip_mb_code = get_bits1(&s->gb);
1349 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1350 else s->per_mb_rl_table= 0;
1352 if(!s->per_mb_rl_table){
1353 s->rl_table_index = decode012(&s->gb);
1354 s->rl_chroma_table_index = s->rl_table_index;
1357 s->dc_table_index = get_bits1(&s->gb);
1359 s->mv_table_index = get_bits1(&s->gb);
1360 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1364 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1365 printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1366 s->use_skip_mb_code,
1368 s->rl_chroma_table_index,
1374 if(s->flipflop_rounding){
1375 s->no_rounding ^= 1;
1380 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1382 s->esc3_level_length= 0;
1383 s->esc3_run_length= 0;
1386 printf("*****frame %d:\n", frame_count++);
1391 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1393 int left= buf_size*8 - get_bits_count(&s->gb);
1394 int length= s->msmpeg4_version>=3 ? 17 : 16;
1395 /* the alt_bitstream reader could read over the end so we need to check it */
1396 if(left>=length && left<length+8)
1400 fps= get_bits(&s->gb, 5);
1401 s->bit_rate= get_bits(&s->gb, 11)*1024;
1402 if(s->msmpeg4_version>=3)
1403 s->flipflop_rounding= get_bits1(&s->gb);
1405 s->flipflop_rounding= 0;
1407 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1409 else if(left<length+8)
1411 s->flipflop_rounding= 0;
1412 if(s->msmpeg4_version != 2)
1413 printf("ext header missing, %d left\n", left);
1417 fprintf(stderr, "I frame too long, ignoring ext header\n");
1423 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1430 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1432 int range, bit_size, sign, code, bits;
1437 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1439 bit_size = s->f_code - 1;
1440 range = 1 << bit_size;
1453 code = (val >> bit_size) + 1;
1454 bits = val & (range - 1);
1456 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1458 put_bits(&s->pb, bit_size, bits);
1463 /* this is identical to h263 except that its range is multiplied by 2 */
1464 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1466 int code, val, sign, shift;
1468 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1469 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1475 sign = get_bits1(&s->gb);
1479 val = (val - 1) << shift;
1480 val |= get_bits(&s->gb, shift);
1495 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1499 if (s->pict_type == P_TYPE) {
1500 if (s->use_skip_mb_code) {
1501 if (get_bits1(&s->gb)) {
1505 s->block_last_index[i] = -1;
1506 s->mv_dir = MV_DIR_FORWARD;
1507 s->mv_type = MV_TYPE_16X16;
1515 if(s->msmpeg4_version==2)
1516 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1518 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1519 if(code<0 || code>7){
1520 fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1524 s->mb_intra = code >>2;
1529 if(s->msmpeg4_version==2)
1530 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1532 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1534 fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1542 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1544 fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1549 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1551 h263_pred_motion(s, 0, &mx, &my);
1552 mx= msmpeg4v2_decode_motion(s, mx, 1);
1553 my= msmpeg4v2_decode_motion(s, my, 1);
1555 s->mv_dir = MV_DIR_FORWARD;
1556 s->mv_type = MV_TYPE_16X16;
1557 s->mv[0][0][0] = mx;
1558 s->mv[0][0][1] = my;
1560 if(s->msmpeg4_version==2){
1561 s->ac_pred = get_bits1(&s->gb);
1562 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1565 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1566 if(s->pict_type==P_TYPE) cbp^=0x3C;
1570 for (i = 0; i < 6; i++) {
1571 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1573 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1580 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1584 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1586 if (s->pict_type == P_TYPE) {
1587 set_stat(ST_INTER_MB);
1588 if (s->use_skip_mb_code) {
1589 if (get_bits1(&s->gb)) {
1593 s->block_last_index[i] = -1;
1594 s->mv_dir = MV_DIR_FORWARD;
1595 s->mv_type = MV_TYPE_16X16;
1599 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1605 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1608 //s->mb_intra = (code & 0x40) ? 0 : 1;
1609 s->mb_intra = (~code & 0x40) >> 6;
1613 set_stat(ST_INTRA_MB);
1615 code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1618 /* predict coded block pattern */
1621 int val = ((code >> (5 - i)) & 1);
1623 int pred = coded_block_pred(s, i, &coded_val);
1627 cbp |= val << (5 - i);
1633 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1634 if(s->per_mb_rl_table && cbp){
1635 s->rl_table_index = decode012(&s->gb);
1636 s->rl_chroma_table_index = s->rl_table_index;
1639 h263_pred_motion(s, 0, &mx, &my);
1640 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1642 s->mv_dir = MV_DIR_FORWARD;
1643 s->mv_type = MV_TYPE_16X16;
1644 s->mv[0][0][0] = mx;
1645 s->mv[0][0][1] = my;
1646 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1648 //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));
1649 set_stat(ST_INTRA_MB);
1650 s->ac_pred = get_bits1(&s->gb);
1651 *mb_type_ptr = MB_TYPE_INTRA;
1652 if(s->inter_intra_pred){
1653 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1654 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1656 if(s->per_mb_rl_table && cbp){
1657 s->rl_table_index = decode012(&s->gb);
1658 s->rl_chroma_table_index = s->rl_table_index;
1662 for (i = 0; i < 6; i++) {
1663 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1665 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1672 //#define ERROR_DETAILS
1673 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1674 int n, int coded, const uint8_t *scan_table)
1676 int level, i, last, run, run_diff;
1679 RL_VLC_ELEM *rl_vlc;
1688 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1691 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1692 if(s->inter_intra_pred) level=0;
1696 rl = &rl_table[s->rl_table_index];
1697 if(level > 256*s->y_dc_scale){
1698 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1699 if(!s->inter_intra_pred) return -1;
1702 rl = &rl_table[3 + s->rl_chroma_table_index];
1703 if(level > 256*s->c_dc_scale){
1704 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1705 if(!s->inter_intra_pred) return -1;
1716 if (dc_pred_dir == 0)
1717 scan_table = s->intra_v_scantable.permutated; /* left */
1719 scan_table = s->intra_h_scantable.permutated; /* top */
1721 scan_table = s->intra_scantable.permutated;
1723 set_stat(ST_INTRA_AC);
1724 rl_vlc= rl->rl_vlc[0];
1726 qmul = s->qscale << 1;
1727 qadd = (s->qscale - 1) | 1;
1729 rl = &rl_table[3 + s->rl_table_index];
1731 if(s->msmpeg4_version==2)
1737 s->block_last_index[n] = i;
1741 scan_table = s->inter_scantable.permutated;
1742 set_stat(ST_INTER_AC);
1743 rl_vlc= rl->rl_vlc[s->qscale];
1746 OPEN_READER(re, &s->gb);
1748 UPDATE_CACHE(re, &s->gb);
1749 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1752 cache= GET_CACHE(re, &s->gb);
1754 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1755 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1757 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1758 UPDATE_CACHE(re, &s->gb);
1759 if(s->msmpeg4_version<=3){
1760 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1761 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1762 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1763 SKIP_COUNTER(re, &s->gb, 1+6+8);
1766 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1767 if(!s->esc3_level_length){
1769 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1771 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1773 if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1774 SKIP_BITS(re, &s->gb, 1);
1779 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1781 SKIP_BITS(re, &s->gb, 1);
1783 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1786 s->esc3_level_length= ll;
1787 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1788 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1789 UPDATE_CACHE(re, &s->gb);
1791 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1792 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1794 sign= SHOW_UBITS(re, &s->gb, 1);
1795 SKIP_BITS(re, &s->gb, 1);
1797 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1798 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1799 if(sign) level= -level;
1801 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1802 #if 0 // waste of time / this will detect very few errors
1804 const int abs_level= ABS(level);
1805 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1806 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1807 if(abs_level <= rl->max_level[last][run]){
1808 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1809 return DECODING_AC_LOST;
1811 if(abs_level <= rl->max_level[last][run]*2){
1812 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1813 return DECODING_AC_LOST;
1815 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1816 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1817 return DECODING_AC_LOST;
1822 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1823 if (level>0) level= level * qmul + qadd;
1824 else level= level * qmul - qadd;
1825 #if 0 // waste of time too :(
1826 if(level>2048 || level<-2048){
1827 fprintf(stderr, "|level| overflow in 3. esc\n");
1828 return DECODING_AC_LOST;
1833 #ifdef ERROR_DETAILS
1835 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1836 else if((i>62 && i<192) || i>192+63)
1837 fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1841 #if MIN_CACHE_BITS < 23
1842 LAST_SKIP_BITS(re, &s->gb, 2);
1843 UPDATE_CACHE(re, &s->gb);
1845 SKIP_BITS(re, &s->gb, 2);
1847 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1848 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //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 ESC2 level=%d\n", level);
1854 else if((i>62 && i<192) || i>192+63)
1855 fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1860 #if MIN_CACHE_BITS < 22
1861 LAST_SKIP_BITS(re, &s->gb, 1);
1862 UPDATE_CACHE(re, &s->gb);
1864 SKIP_BITS(re, &s->gb, 1);
1866 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1868 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1869 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1870 LAST_SKIP_BITS(re, &s->gb, 1);
1871 #ifdef ERROR_DETAILS
1873 fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1874 else if((i>62 && i<192) || i>192+63)
1875 fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1880 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1881 LAST_SKIP_BITS(re, &s->gb, 1);
1882 #ifdef ERROR_DETAILS
1884 fprintf(stderr, "illegal vlc code level=%d\n", level);
1885 else if((i>62 && i<192) || i>192+63)
1886 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1892 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1893 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1894 fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1897 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1902 block[scan_table[i]] = level;
1906 block[scan_table[i]] = level;
1908 CLOSE_READER(re, &s->gb);
1912 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1914 i = 63; /* XXX: not optimal */
1917 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1918 s->block_last_index[n] = i;
1923 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1927 if(s->msmpeg4_version<=2){
1929 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1931 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1936 }else{ //FIXME optimize use unified tables & index
1938 level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1940 level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1943 fprintf(stderr, "illegal dc vlc\n");
1947 if (level == DC_MAX) {
1948 level = get_bits(&s->gb, 8);
1949 if (get_bits1(&s->gb))
1951 } else if (level != 0) {
1952 if (get_bits1(&s->gb))
1957 if(s->msmpeg4_version==1){
1959 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1962 /* update predictor */
1966 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1969 /* update predictor */
1971 *dc_val = level * s->y_dc_scale;
1973 *dc_val = level * s->c_dc_scale;
1980 static int msmpeg4_decode_motion(MpegEncContext * s,
1981 int *mx_ptr, int *my_ptr)
1986 mv = &mv_tables[s->mv_table_index];
1988 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1990 fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1993 if (code == mv->n) {
1994 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1995 mx = get_bits(&s->gb, 6);
1996 my = get_bits(&s->gb, 6);
1998 mx = mv->table_mvx[code];
1999 my = mv->table_mvy[code];
2004 /* WARNING : they do not do exactly modulo encoding */
2019 /* cleanest way to support it
2020 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2021 * as allmost everything would be in the common file