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 #ifdef CONFIG_ENCODERS
62 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
63 #endif //CONFIG_ENCODERS
64 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
65 int n, int coded, const uint8_t *scantable);
66 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
67 static int msmpeg4_decode_motion(MpegEncContext * s,
68 int *mx_ptr, int *my_ptr);
69 #ifdef CONFIG_ENCODERS
70 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
71 #endif //CONFIG_ENCODERS
72 static void init_h263_dc_for_msmpeg4(void);
73 static inline void msmpeg4_memsetw(short *tab, int val, int n);
74 #ifdef CONFIG_ENCODERS
75 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
76 #endif //CONFIG_ENCODERS
77 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
78 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
79 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
81 extern uint32_t inverse[256];
89 #include "msmpeg4data.h"
91 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
95 const char *st_names[ST_NB] = {
105 int st_current_index = 0;
106 unsigned int st_bit_counts[ST_NB];
107 unsigned int st_out_bit_counts[ST_NB];
109 #define set_stat(var) st_current_index = var;
111 void print_stats(void)
119 total += st_bit_counts[i];
122 for(i=0;i<ST_NB;i++) {
123 printf("%-10s : %10.1f %5.1f%%\n",
125 (double)st_bit_counts[i] / 8.0,
126 (double)st_bit_counts[i] * 100.0 / total);
128 printf("%-10s : %10.1f %5.1f%%\n",
136 total += st_out_bit_counts[i];
139 for(i=0;i<ST_NB;i++) {
140 printf("%-10s : %10.1f %5.1f%%\n",
142 (double)st_out_bit_counts[i] / 8.0,
143 (double)st_out_bit_counts[i] * 100.0 / total);
145 printf("%-10s : %10.1f %5.1f%%\n",
153 #define set_stat(var)
157 static void common_init(MpegEncContext * s)
161 switch(s->msmpeg4_version){
165 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
168 if(s->workaround_bugs){
169 s->y_dc_scale_table= old_ff_y_dc_scale_table;
170 s->c_dc_scale_table= old_ff_c_dc_scale_table;
172 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
173 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
178 s->y_dc_scale_table= wmv1_y_dc_scale_table;
179 s->c_dc_scale_table= wmv1_c_dc_scale_table;
184 if(s->msmpeg4_version>=4){
185 ff_init_scantable(s, &s->intra_scantable , wmv1_scantable[1]);
186 ff_init_scantable(s, &s->intra_h_scantable, wmv1_scantable[2]);
187 ff_init_scantable(s, &s->intra_v_scantable, wmv1_scantable[3]);
188 ff_init_scantable(s, &s->inter_scantable , wmv1_scantable[0]);
190 //Note the default tables are set in common_init in mpegvideo.c
195 init_h263_dc_for_msmpeg4();
199 #ifdef CONFIG_ENCODERS
201 /* build the table which associate a (x,y) motion vector to a vlc */
202 static void init_mv_table(MVTable *tab)
206 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
207 /* mark all entries as not used */
209 tab->table_mv_index[i] = tab->n;
211 for(i=0;i<tab->n;i++) {
212 x = tab->table_mvx[i];
213 y = tab->table_mvy[i];
214 tab->table_mv_index[(x << 6) | y] = i;
218 static void code012(PutBitContext *pb, int n)
224 put_bits(pb, 1, (n >= 2));
228 void ff_msmpeg4_encode_init(MpegEncContext *s)
230 static int init_done=0;
234 if(s->msmpeg4_version>=4){
240 /* init various encoding tables */
242 init_mv_table(&mv_tables[0]);
243 init_mv_table(&mv_tables[1]);
244 for(i=0;i<NB_RL_TABLES;i++)
245 init_rl(&rl_table[i]);
247 for(i=0; i<NB_RL_TABLES; i++){
249 for(level=0; level<=MAX_LEVEL; level++){
251 for(run=0; run<=MAX_RUN; run++){
253 for(last=0; last<2; last++){
254 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
262 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
265 int run_diff= intra ? 0 : 1;
267 code = get_rl_index(rl, last, run, level);
268 size+= rl->table_vlc[code][1];
272 level1 = level - rl->max_level[last][run];
275 code = get_rl_index(rl, last, run, level1);
279 if (level > MAX_LEVEL)
281 run1 = run - rl->max_run[last][level] - run_diff;
284 code = get_rl_index(rl, last, run1, level);
291 size+= 1+1+ rl->table_vlc[code][1];
295 size+= 1+1+ rl->table_vlc[code][1];
303 static void find_best_tables(MpegEncContext * s)
306 int best =-1, best_size =9999999;
307 int chroma_best=-1, best_chroma_size=9999999;
318 for(level=0; level<=MAX_LEVEL; level++){
320 for(run=0; run<=MAX_RUN; run++){
322 const int last_size= size + chroma_size;
323 for(last=0; last<2; last++){
324 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
325 int intra_luma_count = s->ac_stats[1][0][level][run][last];
326 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
328 if(s->pict_type==I_TYPE){
329 size += intra_luma_count *rl_length[i ][level][run][last];
330 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
332 size+= intra_luma_count *rl_length[i ][level][run][last]
333 +intra_chroma_count*rl_length[i+3][level][run][last]
334 +inter_count *rl_length[i+3][level][run][last];
337 if(last_size == size+chroma_size) break;
344 if(chroma_size<best_chroma_size){
345 best_chroma_size= chroma_size;
350 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
351 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
353 if(s->pict_type==P_TYPE) chroma_best= best;
355 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
357 s->rl_table_index = best;
358 s->rl_chroma_table_index= chroma_best;
360 if(s->pict_type != s->last_non_b_pict_type){
361 s->rl_table_index= 2;
362 if(s->pict_type==I_TYPE)
363 s->rl_chroma_table_index= 1;
365 s->rl_chroma_table_index= 2;
370 /* write MSMPEG4 compatible frame header */
371 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
375 align_put_bits(&s->pb);
376 put_bits(&s->pb, 2, s->pict_type - 1);
378 put_bits(&s->pb, 5, s->qscale);
379 if(s->msmpeg4_version<=2){
380 s->rl_table_index = 2;
381 s->rl_chroma_table_index = 2;
384 s->dc_table_index = 1;
385 s->mv_table_index = 1; /* only if P frame */
386 s->use_skip_mb_code = 1; /* only if P frame */
387 s->per_mb_rl_table = 0;
388 if(s->msmpeg4_version==4)
389 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
390 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
392 if (s->pict_type == I_TYPE) {
393 s->slice_height= s->mb_height/1;
394 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
396 if(s->msmpeg4_version==4){
397 msmpeg4_encode_ext_header(s);
398 if(s->bit_rate>MBAC_BITRATE)
399 put_bits(&s->pb, 1, s->per_mb_rl_table);
402 if(s->msmpeg4_version>2){
403 if(!s->per_mb_rl_table){
404 code012(&s->pb, s->rl_chroma_table_index);
405 code012(&s->pb, s->rl_table_index);
408 put_bits(&s->pb, 1, s->dc_table_index);
411 put_bits(&s->pb, 1, s->use_skip_mb_code);
413 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
414 put_bits(&s->pb, 1, s->per_mb_rl_table);
416 if(s->msmpeg4_version>2){
417 if(!s->per_mb_rl_table)
418 code012(&s->pb, s->rl_table_index);
420 put_bits(&s->pb, 1, s->dc_table_index);
422 put_bits(&s->pb, 1, s->mv_table_index);
426 s->esc3_level_length= 0;
427 s->esc3_run_length= 0;
431 printf("*****frame %d:\n", frame_count++);
435 void msmpeg4_encode_ext_header(MpegEncContext * s)
437 put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
439 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
441 if(s->msmpeg4_version>=3)
442 put_bits(&s->pb, 1, s->flipflop_rounding);
444 assert(s->flipflop_rounding==0);
447 #endif //CONFIG_ENCODERS
449 /* predict coded block */
450 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
452 int xy, wrap, pred, a, b, c;
454 xy = s->block_index[n];
455 wrap = s->block_wrap[0];
460 a = s->coded_block[xy - 1 ];
461 b = s->coded_block[xy - 1 - wrap];
462 c = s->coded_block[xy - wrap];
471 *coded_block_ptr = &s->coded_block[xy];
476 #ifdef CONFIG_ENCODERS
478 static void msmpeg4_encode_motion(MpegEncContext * s,
484 /* modulo encoding */
485 /* WARNING : you cannot reach all the MVs even with the modulo
486 encoding. This is a somewhat strange compromise they took !!! */
499 if ((unsigned)mx >= 64 ||
501 fprintf(stderr, "error mx=%d my=%d\n", mx, my);
503 mv = &mv_tables[s->mv_table_index];
505 code = mv->table_mv_index[(mx << 6) | my];
508 mv->table_mv_bits[code],
509 mv->table_mv_code[code]);
511 /* escape : code litterally */
512 put_bits(&s->pb, 6, mx);
513 put_bits(&s->pb, 6, my);
517 static inline void handle_slices(MpegEncContext *s){
519 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
520 if(s->msmpeg4_version < 4){
521 ff_mpeg4_clean_buffers(s);
523 s->first_slice_line = 1;
525 s->first_slice_line = 0;
530 void msmpeg4_encode_mb(MpegEncContext * s,
531 DCTELEM block[6][64],
532 int motion_x, int motion_y)
534 int cbp, coded_cbp, i;
536 uint8_t *coded_block;
542 set_stat(ST_INTER_MB);
544 for (i = 0; i < 6; i++) {
545 if (s->block_last_index[i] >= 0)
548 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
549 /* skip macroblock */
550 put_bits(&s->pb, 1, 1);
556 if (s->use_skip_mb_code)
557 put_bits(&s->pb, 1, 0); /* mb coded */
559 if(s->msmpeg4_version<=2){
561 v2_mb_type[cbp&3][1],
562 v2_mb_type[cbp&3][0]);
563 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
567 cbpy_tab[coded_cbp>>2][1],
568 cbpy_tab[coded_cbp>>2][0]);
570 s->misc_bits += get_bits_diff(s);
572 h263_pred_motion(s, 0, &pred_x, &pred_y);
573 msmpeg4v2_encode_motion(s, motion_x - pred_x);
574 msmpeg4v2_encode_motion(s, motion_y - pred_y);
577 table_mb_non_intra[cbp + 64][1],
578 table_mb_non_intra[cbp + 64][0]);
580 s->misc_bits += get_bits_diff(s);
583 h263_pred_motion(s, 0, &pred_x, &pred_y);
584 msmpeg4_encode_motion(s, motion_x - pred_x,
588 s->mv_bits += get_bits_diff(s);
590 for (i = 0; i < 6; i++) {
591 msmpeg4_encode_block(s, block[i], i);
593 s->p_tex_bits += get_bits_diff(s);
598 for (i = 0; i < 6; i++) {
600 val = (s->block_last_index[i] >= 1);
601 cbp |= val << (5 - i);
603 /* predict value for close blocks only for luma */
604 pred = coded_block_pred(s, i, &coded_block);
608 coded_cbp |= val << (5 - i);
612 printf("cbp=%x %x\n", cbp, coded_cbp);
615 if(s->msmpeg4_version<=2){
616 if (s->pict_type == I_TYPE) {
618 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
620 if (s->use_skip_mb_code)
621 put_bits(&s->pb, 1, 0); /* mb coded */
623 v2_mb_type[(cbp&3) + 4][1],
624 v2_mb_type[(cbp&3) + 4][0]);
626 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
629 cbpy_tab[cbp>>2][0]);
631 if (s->pict_type == I_TYPE) {
632 set_stat(ST_INTRA_MB);
634 table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
636 if (s->use_skip_mb_code)
637 put_bits(&s->pb, 1, 0); /* mb coded */
639 table_mb_non_intra[cbp][1],
640 table_mb_non_intra[cbp][0]);
642 set_stat(ST_INTRA_MB);
643 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
644 if(s->inter_intra_pred){
646 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
649 s->misc_bits += get_bits_diff(s);
651 for (i = 0; i < 6; i++) {
652 msmpeg4_encode_block(s, block[i], i);
654 s->i_tex_bits += get_bits_diff(s);
658 #endif //CONFIG_ENCODERS
660 /* old ffmpeg msmpeg4v3 mode */
661 static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
666 }else if (s->qscale < 9){
667 s->y_dc_scale = 2 * s->qscale;
668 s->c_dc_scale = (s->qscale + 13)>>1;
670 s->y_dc_scale = s->qscale + 8;
671 s->c_dc_scale = (s->qscale + 13)>>1;
675 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
676 int32_t **dc_val_ptr)
686 *dc_val_ptr= &s->last_dc[i];
687 return s->last_dc[i];
690 static int get_dc(uint8_t *src, int stride, int scale)
697 sum+=src[x + y*stride];
700 return (sum + (scale>>1))/scale;
703 /* dir = 0: left, dir = 1: top prediction */
704 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
705 uint16_t **dc_val_ptr, int *dir_ptr)
707 int a, b, c, wrap, pred, scale;
710 /* find prediction */
712 scale = s->y_dc_scale;
714 scale = s->c_dc_scale;
717 wrap = s->block_wrap[n];
718 dc_val= s->dc_val[0] + s->block_index[n];
724 b = dc_val[ - 1 - wrap];
727 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
731 /* XXX: the following solution consumes divisions, but it does not
732 necessitate to modify mpegvideo.c. The problem comes from the
733 fact they decided to store the quantized DC (which would lead
734 to problems if Q could vary !) */
735 #if defined ARCH_X86 && !defined PIC
737 "movl %3, %%eax \n\t"
738 "shrl $1, %%eax \n\t"
739 "addl %%eax, %2 \n\t"
740 "addl %%eax, %1 \n\t"
741 "addl %0, %%eax \n\t"
743 "movl %%edx, %0 \n\t"
744 "movl %1, %%eax \n\t"
746 "movl %%edx, %1 \n\t"
747 "movl %2, %%eax \n\t"
749 "movl %%edx, %2 \n\t"
750 : "+b" (a), "+c" (b), "+D" (c)
751 : "g" (scale), "S" (inverse[scale])
755 /* #elif defined (ARCH_ALPHA) */
756 /* Divisions are extremely costly on Alpha; optimize the most
757 common case. But they are costly everywhere...
760 a = (a + (8 >> 1)) / 8;
761 b = (b + (8 >> 1)) / 8;
762 c = (c + (8 >> 1)) / 8;
764 a = (a + (scale >> 1)) / scale;
765 b = (b + (scale >> 1)) / scale;
766 c = (c + (scale >> 1)) / scale;
769 /* XXX: WARNING: they did not choose the same test as MPEG4. This
770 is very important ! */
771 if(s->msmpeg4_version>3){
772 if(s->inter_intra_pred){
783 if (abs(a - b) < abs(b - c)) {
793 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
796 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
798 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
799 else a= get_dc(dest-8, wrap, scale*8);
800 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
801 else c= get_dc(dest-8*wrap, wrap, scale*8);
803 if (s->h263_aic_dir==0) {
806 }else if (s->h263_aic_dir==1) {
814 }else if (s->h263_aic_dir==2) {
828 if (abs(a - b) < abs(b - c)) {
837 if (abs(a - b) <= abs(b - c)) {
846 /* update predictor */
847 *dc_val_ptr = &dc_val[0];
853 #ifdef CONFIG_ENCODERS
855 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
860 if(s->msmpeg4_version==1){
862 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
864 /* update predictor */
868 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
870 /* update predictor */
872 *dc_val = level * s->y_dc_scale;
874 *dc_val = level * s->c_dc_scale;
878 /* do the prediction */
881 if(s->msmpeg4_version<=2){
884 v2_dc_lum_table[level+256][1],
885 v2_dc_lum_table[level+256][0]);
888 v2_dc_chroma_table[level+256][1],
889 v2_dc_chroma_table[level+256][0]);
901 if (s->dc_table_index == 0) {
903 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
905 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
909 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
911 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
916 put_bits(&s->pb, 8, level);
919 put_bits(&s->pb, 1, sign);
924 /* Encoding of a block. Very similar to MPEG4 except for a different
925 escape coding (same as H263) and more vlc tables.
927 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
929 int level, run, last, i, j, last_index;
930 int last_non_zero, sign, slevel;
931 int code, run_diff, dc_pred_dir;
933 const uint8_t *scantable;
937 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
940 rl = &rl_table[s->rl_table_index];
942 rl = &rl_table[3 + s->rl_chroma_table_index];
945 scantable= s->intra_scantable.permutated;
946 set_stat(ST_INTRA_AC);
949 rl = &rl_table[3 + s->rl_table_index];
950 if(s->msmpeg4_version<=2)
954 scantable= s->inter_scantable.permutated;
955 set_stat(ST_INTER_AC);
958 /* recalculate block_last_index for M$ wmv1 */
959 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
960 for(last_index=63; last_index>=0; last_index--){
961 if(block[scantable[last_index]]) break;
963 s->block_last_index[n]= last_index;
965 last_index = s->block_last_index[n];
967 last_non_zero = i - 1;
968 for (; i <= last_index; i++) {
972 run = i - last_non_zero - 1;
973 last = (i == last_index);
981 if(level<=MAX_LEVEL && run<=MAX_RUN){
982 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
986 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
988 code = get_rl_index(rl, last, run, level);
989 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
993 level1 = level - rl->max_level[last][run];
996 code = get_rl_index(rl, last, run, level1);
999 put_bits(&s->pb, 1, 0);
1000 if (level > MAX_LEVEL)
1002 run1 = run - rl->max_run[last][level] - run_diff;
1005 code = get_rl_index(rl, last, run1, level);
1006 if (code == rl->n) {
1009 put_bits(&s->pb, 1, 0);
1010 put_bits(&s->pb, 1, last);
1011 if(s->msmpeg4_version>=4){
1012 if(s->esc3_level_length==0){
1013 s->esc3_level_length=8;
1014 s->esc3_run_length= 6;
1016 put_bits(&s->pb, 6, 3);
1018 put_bits(&s->pb, 8, 3);
1020 put_bits(&s->pb, s->esc3_run_length, run);
1021 put_bits(&s->pb, 1, sign);
1022 put_bits(&s->pb, s->esc3_level_length, level);
1024 put_bits(&s->pb, 6, run);
1025 put_bits(&s->pb, 8, slevel & 0xff);
1029 put_bits(&s->pb, 1, 1);
1030 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1031 put_bits(&s->pb, 1, sign);
1035 put_bits(&s->pb, 1, 1);
1036 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1037 put_bits(&s->pb, 1, sign);
1040 put_bits(&s->pb, 1, sign);
1047 #endif //CONFIG_ENCODERS
1049 /****************************************/
1050 /* decoding stuff */
1052 static VLC mb_non_intra_vlc[4];
1053 static VLC mb_intra_vlc;
1054 static VLC dc_lum_vlc[2];
1055 static VLC dc_chroma_vlc[2];
1056 static VLC v2_dc_lum_vlc;
1057 static VLC v2_dc_chroma_vlc;
1058 static VLC cbpy_vlc;
1059 static VLC v2_intra_cbpc_vlc;
1060 static VLC v2_mb_type_vlc;
1061 static VLC v2_mv_vlc;
1062 static VLC v1_intra_cbpc_vlc;
1063 static VLC v1_inter_cbpc_vlc;
1064 static VLC inter_intra_vlc;
1066 /* this table is practically identical to the one from h263 except that its inverted */
1067 static void init_h263_dc_for_msmpeg4(void)
1069 int level, uni_code, uni_len;
1071 for(level=-256; level<256; level++){
1073 /* find number of bits */
1082 l= (-level) ^ ((1 << size) - 1);
1086 /* luminance h263 */
1087 uni_code= DCtab_lum[size][0];
1088 uni_len = DCtab_lum[size][1];
1089 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1092 uni_code<<=size; uni_code|=l;
1095 uni_code<<=1; uni_code|=1;
1099 v2_dc_lum_table[level+256][0]= uni_code;
1100 v2_dc_lum_table[level+256][1]= uni_len;
1102 /* chrominance h263 */
1103 uni_code= DCtab_chrom[size][0];
1104 uni_len = DCtab_chrom[size][1];
1105 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1108 uni_code<<=size; uni_code|=l;
1111 uni_code<<=1; uni_code|=1;
1115 v2_dc_chroma_table[level+256][0]= uni_code;
1116 v2_dc_chroma_table[level+256][1]= uni_len;
1121 /* init all vlc decoding tables */
1122 int ff_msmpeg4_decode_init(MpegEncContext *s)
1124 static int done = 0;
1133 for(i=0;i<NB_RL_TABLES;i++) {
1134 init_rl(&rl_table[i]);
1135 init_vlc_rl(&rl_table[i]);
1139 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1140 mv->table_mv_bits, 1, 1,
1141 mv->table_mv_code, 2, 2);
1144 init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120,
1145 &table0_dc_lum[0][1], 8, 4,
1146 &table0_dc_lum[0][0], 8, 4);
1147 init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120,
1148 &table0_dc_chroma[0][1], 8, 4,
1149 &table0_dc_chroma[0][0], 8, 4);
1150 init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120,
1151 &table1_dc_lum[0][1], 8, 4,
1152 &table1_dc_lum[0][0], 8, 4);
1153 init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120,
1154 &table1_dc_chroma[0][1], 8, 4,
1155 &table1_dc_chroma[0][0], 8, 4);
1157 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1158 &v2_dc_lum_table[0][1], 8, 4,
1159 &v2_dc_lum_table[0][0], 8, 4);
1160 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1161 &v2_dc_chroma_table[0][1], 8, 4,
1162 &v2_dc_chroma_table[0][0], 8, 4);
1164 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1165 &cbpy_tab[0][1], 2, 1,
1166 &cbpy_tab[0][0], 2, 1);
1167 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1168 &v2_intra_cbpc[0][1], 2, 1,
1169 &v2_intra_cbpc[0][0], 2, 1);
1170 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1171 &v2_mb_type[0][1], 2, 1,
1172 &v2_mb_type[0][0], 2, 1);
1173 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1175 &mvtab[0][0], 2, 1);
1178 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1179 &wmv2_inter_table[i][0][1], 8, 4,
1180 &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1183 init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,
1184 &table_mb_intra[0][1], 4, 2,
1185 &table_mb_intra[0][0], 4, 2);
1187 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1188 intra_MCBPC_bits, 1, 1,
1189 intra_MCBPC_code, 1, 1);
1190 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1191 inter_MCBPC_bits, 1, 1,
1192 inter_MCBPC_code, 1, 1);
1194 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1195 &table_inter_intra[0][1], 2, 1,
1196 &table_inter_intra[0][0], 2, 1);
1199 switch(s->msmpeg4_version){
1202 s->decode_mb= msmpeg4v12_decode_mb;
1206 s->decode_mb= msmpeg4v34_decode_mb;
1209 s->decode_mb= wmv2_decode_mb;
1213 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1218 static int decode012(GetBitContext *gb)
1225 return get_bits1(gb) + 1;
1228 int msmpeg4_decode_picture_header(MpegEncContext * s)
1235 for(i=0; i<s->gb.size_in_bits; i++)
1236 printf("%d", get_bits1(&s->gb));
1237 // get_bits1(&s->gb);
1243 if(s->msmpeg4_version==1){
1244 int start_code, num;
1245 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1246 if(start_code!=0x00000100){
1247 fprintf(stderr, "invalid startcode\n");
1251 num= get_bits(&s->gb, 5); // frame number */
1254 s->pict_type = get_bits(&s->gb, 2) + 1;
1255 if (s->pict_type != I_TYPE &&
1256 s->pict_type != P_TYPE){
1257 fprintf(stderr, "invalid picture type\n");
1263 if(s->pict_type == I_TYPE) had_i=1;
1264 if(!had_i) return -1;
1267 s->qscale = get_bits(&s->gb, 5);
1269 fprintf(stderr, "invalid qscale\n");
1273 if (s->pict_type == I_TYPE) {
1274 code = get_bits(&s->gb, 5);
1275 if(s->msmpeg4_version==1){
1276 if(code==0 || code>s->mb_height){
1277 fprintf(stderr, "invalid slice height %d\n", code);
1281 s->slice_height = code;
1283 /* 0x17: one slice, 0x18: two slices, ... */
1285 fprintf(stderr, "error, slice code was %X\n", code);
1289 s->slice_height = s->mb_height / (code - 0x16);
1292 switch(s->msmpeg4_version){
1295 s->rl_chroma_table_index = 2;
1296 s->rl_table_index = 2;
1298 s->dc_table_index = 0; //not used
1301 s->rl_chroma_table_index = decode012(&s->gb);
1302 s->rl_table_index = decode012(&s->gb);
1304 s->dc_table_index = get_bits1(&s->gb);
1307 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1309 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1310 else s->per_mb_rl_table= 0;
1312 if(!s->per_mb_rl_table){
1313 s->rl_chroma_table_index = decode012(&s->gb);
1314 s->rl_table_index = decode012(&s->gb);
1317 s->dc_table_index = get_bits1(&s->gb);
1318 s->inter_intra_pred= 0;
1322 /* printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1324 s->rl_chroma_table_index,
1330 switch(s->msmpeg4_version){
1333 if(s->msmpeg4_version==1)
1334 s->use_skip_mb_code = 1;
1336 s->use_skip_mb_code = get_bits1(&s->gb);
1337 s->rl_table_index = 2;
1338 s->rl_chroma_table_index = s->rl_table_index;
1339 s->dc_table_index = 0; //not used
1340 s->mv_table_index = 0;
1343 s->use_skip_mb_code = get_bits1(&s->gb);
1344 s->rl_table_index = decode012(&s->gb);
1345 s->rl_chroma_table_index = s->rl_table_index;
1347 s->dc_table_index = get_bits1(&s->gb);
1349 s->mv_table_index = get_bits1(&s->gb);
1352 s->use_skip_mb_code = get_bits1(&s->gb);
1354 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1355 else s->per_mb_rl_table= 0;
1357 if(!s->per_mb_rl_table){
1358 s->rl_table_index = decode012(&s->gb);
1359 s->rl_chroma_table_index = s->rl_table_index;
1362 s->dc_table_index = get_bits1(&s->gb);
1364 s->mv_table_index = get_bits1(&s->gb);
1365 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1368 /* printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1369 s->use_skip_mb_code,
1371 s->rl_chroma_table_index,
1376 if(s->flipflop_rounding){
1377 s->no_rounding ^= 1;
1382 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1384 s->esc3_level_length= 0;
1385 s->esc3_run_length= 0;
1388 printf("*****frame %d:\n", frame_count++);
1393 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1395 int left= buf_size*8 - get_bits_count(&s->gb);
1396 int length= s->msmpeg4_version>=3 ? 17 : 16;
1397 /* the alt_bitstream reader could read over the end so we need to check it */
1398 if(left>=length && left<length+8)
1402 fps= get_bits(&s->gb, 5);
1403 s->bit_rate= get_bits(&s->gb, 11)*1024;
1404 if(s->msmpeg4_version>=3)
1405 s->flipflop_rounding= get_bits1(&s->gb);
1407 s->flipflop_rounding= 0;
1409 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1411 else if(left<length+8)
1413 s->flipflop_rounding= 0;
1414 printf("ext header missing, %d left\n", left);
1418 fprintf(stderr, "I frame too long, ignoring ext header\n");
1424 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1431 #ifdef CONFIG_ENCODERS
1433 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1435 int range, bit_size, sign, code, bits;
1440 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1442 bit_size = s->f_code - 1;
1443 range = 1 << bit_size;
1456 code = (val >> bit_size) + 1;
1457 bits = val & (range - 1);
1459 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1461 put_bits(&s->pb, bit_size, bits);
1466 #endif //CONFIG_ENCODERS
1468 /* this is identical to h263 except that its range is multiplied by 2 */
1469 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1471 int code, val, sign, shift;
1473 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1474 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1480 sign = get_bits1(&s->gb);
1482 val = (code - 1) << shift;
1484 val |= get_bits(&s->gb, shift);
1498 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1502 if (s->pict_type == P_TYPE) {
1503 if (s->use_skip_mb_code) {
1504 if (get_bits1(&s->gb)) {
1508 s->block_last_index[i] = -1;
1509 s->mv_dir = MV_DIR_FORWARD;
1510 s->mv_type = MV_TYPE_16X16;
1518 if(s->msmpeg4_version==2)
1519 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1521 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1522 if(code<0 || code>7){
1523 fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1527 s->mb_intra = code >>2;
1532 if(s->msmpeg4_version==2)
1533 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1535 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1537 fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1545 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1547 fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1552 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1554 h263_pred_motion(s, 0, &mx, &my);
1555 mx= msmpeg4v2_decode_motion(s, mx, 1);
1556 my= msmpeg4v2_decode_motion(s, my, 1);
1558 s->mv_dir = MV_DIR_FORWARD;
1559 s->mv_type = MV_TYPE_16X16;
1560 s->mv[0][0][0] = mx;
1561 s->mv[0][0][1] = my;
1563 if(s->msmpeg4_version==2){
1564 s->ac_pred = get_bits1(&s->gb);
1565 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1568 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1569 if(s->pict_type==P_TYPE) cbp^=0x3C;
1573 for (i = 0; i < 6; i++) {
1574 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1576 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1583 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1587 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1589 if (s->pict_type == P_TYPE) {
1590 set_stat(ST_INTER_MB);
1591 if (s->use_skip_mb_code) {
1592 if (get_bits1(&s->gb)) {
1596 s->block_last_index[i] = -1;
1597 s->mv_dir = MV_DIR_FORWARD;
1598 s->mv_type = MV_TYPE_16X16;
1602 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1608 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1611 //s->mb_intra = (code & 0x40) ? 0 : 1;
1612 s->mb_intra = (~code & 0x40) >> 6;
1616 set_stat(ST_INTRA_MB);
1618 code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1621 /* predict coded block pattern */
1624 int val = ((code >> (5 - i)) & 1);
1626 int pred = coded_block_pred(s, i, &coded_val);
1630 cbp |= val << (5 - i);
1636 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1637 if(s->per_mb_rl_table && cbp){
1638 s->rl_table_index = decode012(&s->gb);
1639 s->rl_chroma_table_index = s->rl_table_index;
1642 h263_pred_motion(s, 0, &mx, &my);
1643 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1645 s->mv_dir = MV_DIR_FORWARD;
1646 s->mv_type = MV_TYPE_16X16;
1647 s->mv[0][0][0] = mx;
1648 s->mv[0][0][1] = my;
1649 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1651 //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));
1652 set_stat(ST_INTRA_MB);
1653 s->ac_pred = get_bits1(&s->gb);
1654 *mb_type_ptr = MB_TYPE_INTRA;
1655 if(s->inter_intra_pred){
1656 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1657 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1659 if(s->per_mb_rl_table && cbp){
1660 s->rl_table_index = decode012(&s->gb);
1661 s->rl_chroma_table_index = s->rl_table_index;
1665 for (i = 0; i < 6; i++) {
1666 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1668 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1675 //#define ERROR_DETAILS
1676 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1677 int n, int coded, const uint8_t *scan_table)
1679 int level, i, last, run, run_diff;
1682 RL_VLC_ELEM *rl_vlc;
1691 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1694 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1695 if(s->inter_intra_pred) level=0;
1699 rl = &rl_table[s->rl_table_index];
1700 if(level > 256*s->y_dc_scale){
1701 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1702 if(!s->inter_intra_pred) return -1;
1705 rl = &rl_table[3 + s->rl_chroma_table_index];
1706 if(level > 256*s->c_dc_scale){
1707 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1708 if(!s->inter_intra_pred) return -1;
1719 if (dc_pred_dir == 0)
1720 scan_table = s->intra_v_scantable.permutated; /* left */
1722 scan_table = s->intra_h_scantable.permutated; /* top */
1724 scan_table = s->intra_scantable.permutated;
1726 set_stat(ST_INTRA_AC);
1727 rl_vlc= rl->rl_vlc[0];
1729 qmul = s->qscale << 1;
1730 qadd = (s->qscale - 1) | 1;
1732 rl = &rl_table[3 + s->rl_table_index];
1734 if(s->msmpeg4_version==2)
1740 s->block_last_index[n] = i;
1744 scan_table = s->inter_scantable.permutated;
1745 set_stat(ST_INTER_AC);
1746 rl_vlc= rl->rl_vlc[s->qscale];
1749 OPEN_READER(re, &s->gb);
1751 UPDATE_CACHE(re, &s->gb);
1752 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1755 cache= GET_CACHE(re, &s->gb);
1757 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1758 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1760 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1761 UPDATE_CACHE(re, &s->gb);
1762 if(s->msmpeg4_version<=3){
1763 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1764 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1765 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1766 SKIP_COUNTER(re, &s->gb, 1+6+8);
1769 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1770 if(!s->esc3_level_length){
1772 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1774 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1776 if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1777 SKIP_BITS(re, &s->gb, 1);
1782 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1784 SKIP_BITS(re, &s->gb, 1);
1786 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1789 s->esc3_level_length= ll;
1790 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1791 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1792 UPDATE_CACHE(re, &s->gb);
1794 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1795 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1797 sign= SHOW_UBITS(re, &s->gb, 1);
1798 SKIP_BITS(re, &s->gb, 1);
1800 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1801 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1802 if(sign) level= -level;
1804 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1805 #if 0 // waste of time / this will detect very few errors
1807 const int abs_level= ABS(level);
1808 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1809 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1810 if(abs_level <= rl->max_level[last][run]){
1811 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1812 return DECODING_AC_LOST;
1814 if(abs_level <= rl->max_level[last][run]*2){
1815 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1816 return DECODING_AC_LOST;
1818 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1819 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1820 return DECODING_AC_LOST;
1825 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1826 if (level>0) level= level * qmul + qadd;
1827 else level= level * qmul - qadd;
1828 #if 0 // waste of time too :(
1829 if(level>2048 || level<-2048){
1830 fprintf(stderr, "|level| overflow in 3. esc\n");
1831 return DECODING_AC_LOST;
1836 #ifdef ERROR_DETAILS
1838 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1839 else if((i>62 && i<192) || i>192+63)
1840 fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1844 #if MIN_CACHE_BITS < 23
1845 LAST_SKIP_BITS(re, &s->gb, 2);
1846 UPDATE_CACHE(re, &s->gb);
1848 SKIP_BITS(re, &s->gb, 2);
1850 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1851 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1852 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1853 LAST_SKIP_BITS(re, &s->gb, 1);
1854 #ifdef ERROR_DETAILS
1856 fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1857 else if((i>62 && i<192) || i>192+63)
1858 fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1863 #if MIN_CACHE_BITS < 22
1864 LAST_SKIP_BITS(re, &s->gb, 1);
1865 UPDATE_CACHE(re, &s->gb);
1867 SKIP_BITS(re, &s->gb, 1);
1869 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1871 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1872 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1873 LAST_SKIP_BITS(re, &s->gb, 1);
1874 #ifdef ERROR_DETAILS
1876 fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1877 else if((i>62 && i<192) || i>192+63)
1878 fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1883 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1884 LAST_SKIP_BITS(re, &s->gb, 1);
1885 #ifdef ERROR_DETAILS
1887 fprintf(stderr, "illegal vlc code level=%d\n", level);
1888 else if((i>62 && i<192) || i>192+63)
1889 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1895 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1896 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1897 fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1900 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1905 block[scan_table[i]] = level;
1909 block[scan_table[i]] = level;
1911 CLOSE_READER(re, &s->gb);
1915 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1917 i = 63; /* XXX: not optimal */
1920 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1921 s->block_last_index[n] = i;
1926 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1930 if(s->msmpeg4_version<=2){
1932 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1934 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1939 }else{ //FIXME optimize use unified tables & index
1941 level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1943 level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1946 fprintf(stderr, "illegal dc vlc\n");
1950 if (level == DC_MAX) {
1951 level = get_bits(&s->gb, 8);
1952 if (get_bits1(&s->gb))
1954 } else if (level != 0) {
1955 if (get_bits1(&s->gb))
1960 if(s->msmpeg4_version==1){
1962 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1965 /* update predictor */
1969 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1972 /* update predictor */
1974 *dc_val = level * s->y_dc_scale;
1976 *dc_val = level * s->c_dc_scale;
1983 static int msmpeg4_decode_motion(MpegEncContext * s,
1984 int *mx_ptr, int *my_ptr)
1989 mv = &mv_tables[s->mv_table_index];
1991 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1993 fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1996 if (code == mv->n) {
1997 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1998 mx = get_bits(&s->gb, 6);
1999 my = get_bits(&s->gb, 6);
2001 mx = mv->table_mvx[code];
2002 my = mv->table_mvy[code];
2007 /* WARNING : they do not do exactly modulo encoding */
2022 /* cleanest way to support it
2023 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2024 * as allmost everything would be in the common file