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);
557 if (s->use_skip_mb_code)
558 put_bits(&s->pb, 1, 0); /* mb coded */
560 if(s->msmpeg4_version<=2){
562 v2_mb_type[cbp&3][1],
563 v2_mb_type[cbp&3][0]);
564 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
568 cbpy_tab[coded_cbp>>2][1],
569 cbpy_tab[coded_cbp>>2][0]);
571 s->misc_bits += get_bits_diff(s);
573 h263_pred_motion(s, 0, &pred_x, &pred_y);
574 msmpeg4v2_encode_motion(s, motion_x - pred_x);
575 msmpeg4v2_encode_motion(s, motion_y - pred_y);
578 table_mb_non_intra[cbp + 64][1],
579 table_mb_non_intra[cbp + 64][0]);
581 s->misc_bits += get_bits_diff(s);
584 h263_pred_motion(s, 0, &pred_x, &pred_y);
585 msmpeg4_encode_motion(s, motion_x - pred_x,
589 s->mv_bits += get_bits_diff(s);
591 for (i = 0; i < 6; i++) {
592 msmpeg4_encode_block(s, block[i], i);
594 s->p_tex_bits += get_bits_diff(s);
599 for (i = 0; i < 6; i++) {
601 val = (s->block_last_index[i] >= 1);
602 cbp |= val << (5 - i);
604 /* predict value for close blocks only for luma */
605 pred = coded_block_pred(s, i, &coded_block);
609 coded_cbp |= val << (5 - i);
613 printf("cbp=%x %x\n", cbp, coded_cbp);
616 if(s->msmpeg4_version<=2){
617 if (s->pict_type == I_TYPE) {
619 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
621 if (s->use_skip_mb_code)
622 put_bits(&s->pb, 1, 0); /* mb coded */
624 v2_mb_type[(cbp&3) + 4][1],
625 v2_mb_type[(cbp&3) + 4][0]);
627 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
630 cbpy_tab[cbp>>2][0]);
632 if (s->pict_type == I_TYPE) {
633 set_stat(ST_INTRA_MB);
635 table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
637 if (s->use_skip_mb_code)
638 put_bits(&s->pb, 1, 0); /* mb coded */
640 table_mb_non_intra[cbp][1],
641 table_mb_non_intra[cbp][0]);
643 set_stat(ST_INTRA_MB);
644 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
645 if(s->inter_intra_pred){
647 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
650 s->misc_bits += get_bits_diff(s);
652 for (i = 0; i < 6; i++) {
653 msmpeg4_encode_block(s, block[i], i);
655 s->i_tex_bits += get_bits_diff(s);
660 #endif //CONFIG_ENCODERS
662 /* old ffmpeg msmpeg4v3 mode */
663 static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
668 }else if (s->qscale < 9){
669 s->y_dc_scale = 2 * s->qscale;
670 s->c_dc_scale = (s->qscale + 13)>>1;
672 s->y_dc_scale = s->qscale + 8;
673 s->c_dc_scale = (s->qscale + 13)>>1;
677 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
678 int32_t **dc_val_ptr)
688 *dc_val_ptr= &s->last_dc[i];
689 return s->last_dc[i];
692 static int get_dc(uint8_t *src, int stride, int scale)
699 sum+=src[x + y*stride];
702 return (sum + (scale>>1))/scale;
705 /* dir = 0: left, dir = 1: top prediction */
706 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
707 uint16_t **dc_val_ptr, int *dir_ptr)
709 int a, b, c, wrap, pred, scale;
712 /* find prediction */
714 scale = s->y_dc_scale;
716 scale = s->c_dc_scale;
719 wrap = s->block_wrap[n];
720 dc_val= s->dc_val[0] + s->block_index[n];
726 b = dc_val[ - 1 - wrap];
729 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
733 /* XXX: the following solution consumes divisions, but it does not
734 necessitate to modify mpegvideo.c. The problem comes from the
735 fact they decided to store the quantized DC (which would lead
736 to problems if Q could vary !) */
737 #if defined ARCH_X86 && !defined PIC
739 "movl %3, %%eax \n\t"
740 "shrl $1, %%eax \n\t"
741 "addl %%eax, %2 \n\t"
742 "addl %%eax, %1 \n\t"
743 "addl %0, %%eax \n\t"
745 "movl %%edx, %0 \n\t"
746 "movl %1, %%eax \n\t"
748 "movl %%edx, %1 \n\t"
749 "movl %2, %%eax \n\t"
751 "movl %%edx, %2 \n\t"
752 : "+b" (a), "+c" (b), "+D" (c)
753 : "g" (scale), "S" (inverse[scale])
757 /* #elif defined (ARCH_ALPHA) */
758 /* Divisions are extremely costly on Alpha; optimize the most
759 common case. But they are costly everywhere...
762 a = (a + (8 >> 1)) / 8;
763 b = (b + (8 >> 1)) / 8;
764 c = (c + (8 >> 1)) / 8;
766 a = (a + (scale >> 1)) / scale;
767 b = (b + (scale >> 1)) / scale;
768 c = (c + (scale >> 1)) / scale;
771 /* XXX: WARNING: they did not choose the same test as MPEG4. This
772 is very important ! */
773 if(s->msmpeg4_version>3){
774 if(s->inter_intra_pred){
785 if (abs(a - b) < abs(b - c)) {
795 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
798 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
800 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
801 else a= get_dc(dest-8, wrap, scale*8);
802 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
803 else c= get_dc(dest-8*wrap, wrap, scale*8);
805 if (s->h263_aic_dir==0) {
808 }else if (s->h263_aic_dir==1) {
816 }else if (s->h263_aic_dir==2) {
830 if (abs(a - b) < abs(b - c)) {
839 if (abs(a - b) <= abs(b - c)) {
848 /* update predictor */
849 *dc_val_ptr = &dc_val[0];
855 #ifdef CONFIG_ENCODERS
857 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
862 if(s->msmpeg4_version==1){
864 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
866 /* update predictor */
870 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
872 /* update predictor */
874 *dc_val = level * s->y_dc_scale;
876 *dc_val = level * s->c_dc_scale;
880 /* do the prediction */
883 if(s->msmpeg4_version<=2){
886 v2_dc_lum_table[level+256][1],
887 v2_dc_lum_table[level+256][0]);
890 v2_dc_chroma_table[level+256][1],
891 v2_dc_chroma_table[level+256][0]);
903 if (s->dc_table_index == 0) {
905 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
907 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
911 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
913 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
918 put_bits(&s->pb, 8, level);
921 put_bits(&s->pb, 1, sign);
926 /* Encoding of a block. Very similar to MPEG4 except for a different
927 escape coding (same as H263) and more vlc tables.
929 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
931 int level, run, last, i, j, last_index;
932 int last_non_zero, sign, slevel;
933 int code, run_diff, dc_pred_dir;
935 const uint8_t *scantable;
939 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
942 rl = &rl_table[s->rl_table_index];
944 rl = &rl_table[3 + s->rl_chroma_table_index];
947 scantable= s->intra_scantable.permutated;
948 set_stat(ST_INTRA_AC);
951 rl = &rl_table[3 + s->rl_table_index];
952 if(s->msmpeg4_version<=2)
956 scantable= s->inter_scantable.permutated;
957 set_stat(ST_INTER_AC);
960 /* recalculate block_last_index for M$ wmv1 */
961 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
962 for(last_index=63; last_index>=0; last_index--){
963 if(block[scantable[last_index]]) break;
965 s->block_last_index[n]= last_index;
967 last_index = s->block_last_index[n];
969 last_non_zero = i - 1;
970 for (; i <= last_index; i++) {
974 run = i - last_non_zero - 1;
975 last = (i == last_index);
983 if(level<=MAX_LEVEL && run<=MAX_RUN){
984 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
988 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
990 code = get_rl_index(rl, last, run, level);
991 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
995 level1 = level - rl->max_level[last][run];
998 code = get_rl_index(rl, last, run, level1);
1001 put_bits(&s->pb, 1, 0);
1002 if (level > MAX_LEVEL)
1004 run1 = run - rl->max_run[last][level] - run_diff;
1007 code = get_rl_index(rl, last, run1, level);
1008 if (code == rl->n) {
1011 put_bits(&s->pb, 1, 0);
1012 put_bits(&s->pb, 1, last);
1013 if(s->msmpeg4_version>=4){
1014 if(s->esc3_level_length==0){
1015 s->esc3_level_length=8;
1016 s->esc3_run_length= 6;
1018 put_bits(&s->pb, 6, 3);
1020 put_bits(&s->pb, 8, 3);
1022 put_bits(&s->pb, s->esc3_run_length, run);
1023 put_bits(&s->pb, 1, sign);
1024 put_bits(&s->pb, s->esc3_level_length, level);
1026 put_bits(&s->pb, 6, run);
1027 put_bits(&s->pb, 8, slevel & 0xff);
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);
1037 put_bits(&s->pb, 1, 1);
1038 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1039 put_bits(&s->pb, 1, sign);
1042 put_bits(&s->pb, 1, sign);
1049 #endif //CONFIG_ENCODERS
1051 /****************************************/
1052 /* decoding stuff */
1054 static VLC mb_non_intra_vlc[4];
1055 static VLC mb_intra_vlc;
1056 static VLC dc_lum_vlc[2];
1057 static VLC dc_chroma_vlc[2];
1058 static VLC v2_dc_lum_vlc;
1059 static VLC v2_dc_chroma_vlc;
1060 static VLC cbpy_vlc;
1061 static VLC v2_intra_cbpc_vlc;
1062 static VLC v2_mb_type_vlc;
1063 static VLC v2_mv_vlc;
1064 static VLC v1_intra_cbpc_vlc;
1065 static VLC v1_inter_cbpc_vlc;
1066 static VLC inter_intra_vlc;
1068 /* this table is practically identical to the one from h263 except that its inverted */
1069 static void init_h263_dc_for_msmpeg4(void)
1071 int level, uni_code, uni_len;
1073 for(level=-256; level<256; level++){
1075 /* find number of bits */
1084 l= (-level) ^ ((1 << size) - 1);
1088 /* luminance h263 */
1089 uni_code= DCtab_lum[size][0];
1090 uni_len = DCtab_lum[size][1];
1091 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1094 uni_code<<=size; uni_code|=l;
1097 uni_code<<=1; uni_code|=1;
1101 v2_dc_lum_table[level+256][0]= uni_code;
1102 v2_dc_lum_table[level+256][1]= uni_len;
1104 /* chrominance h263 */
1105 uni_code= DCtab_chrom[size][0];
1106 uni_len = DCtab_chrom[size][1];
1107 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1110 uni_code<<=size; uni_code|=l;
1113 uni_code<<=1; uni_code|=1;
1117 v2_dc_chroma_table[level+256][0]= uni_code;
1118 v2_dc_chroma_table[level+256][1]= uni_len;
1123 /* init all vlc decoding tables */
1124 int ff_msmpeg4_decode_init(MpegEncContext *s)
1126 static int done = 0;
1135 for(i=0;i<NB_RL_TABLES;i++) {
1136 init_rl(&rl_table[i]);
1137 init_vlc_rl(&rl_table[i]);
1141 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1142 mv->table_mv_bits, 1, 1,
1143 mv->table_mv_code, 2, 2);
1146 init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120,
1147 &table0_dc_lum[0][1], 8, 4,
1148 &table0_dc_lum[0][0], 8, 4);
1149 init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120,
1150 &table0_dc_chroma[0][1], 8, 4,
1151 &table0_dc_chroma[0][0], 8, 4);
1152 init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120,
1153 &table1_dc_lum[0][1], 8, 4,
1154 &table1_dc_lum[0][0], 8, 4);
1155 init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120,
1156 &table1_dc_chroma[0][1], 8, 4,
1157 &table1_dc_chroma[0][0], 8, 4);
1159 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1160 &v2_dc_lum_table[0][1], 8, 4,
1161 &v2_dc_lum_table[0][0], 8, 4);
1162 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1163 &v2_dc_chroma_table[0][1], 8, 4,
1164 &v2_dc_chroma_table[0][0], 8, 4);
1166 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1167 &cbpy_tab[0][1], 2, 1,
1168 &cbpy_tab[0][0], 2, 1);
1169 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1170 &v2_intra_cbpc[0][1], 2, 1,
1171 &v2_intra_cbpc[0][0], 2, 1);
1172 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1173 &v2_mb_type[0][1], 2, 1,
1174 &v2_mb_type[0][0], 2, 1);
1175 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1177 &mvtab[0][0], 2, 1);
1180 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1181 &wmv2_inter_table[i][0][1], 8, 4,
1182 &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1185 init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,
1186 &table_mb_intra[0][1], 4, 2,
1187 &table_mb_intra[0][0], 4, 2);
1189 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1190 intra_MCBPC_bits, 1, 1,
1191 intra_MCBPC_code, 1, 1);
1192 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1193 inter_MCBPC_bits, 1, 1,
1194 inter_MCBPC_code, 1, 1);
1196 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1197 &table_inter_intra[0][1], 2, 1,
1198 &table_inter_intra[0][0], 2, 1);
1201 switch(s->msmpeg4_version){
1204 s->decode_mb= msmpeg4v12_decode_mb;
1208 s->decode_mb= msmpeg4v34_decode_mb;
1211 s->decode_mb= wmv2_decode_mb;
1215 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1220 static int decode012(GetBitContext *gb)
1227 return get_bits1(gb) + 1;
1230 int msmpeg4_decode_picture_header(MpegEncContext * s)
1237 for(i=0; i<s->gb.size_in_bits; i++)
1238 printf("%d", get_bits1(&s->gb));
1239 // get_bits1(&s->gb);
1245 if(s->msmpeg4_version==1){
1246 int start_code, num;
1247 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1248 if(start_code!=0x00000100){
1249 fprintf(stderr, "invalid startcode\n");
1253 num= get_bits(&s->gb, 5); // frame number */
1256 s->pict_type = get_bits(&s->gb, 2) + 1;
1257 if (s->pict_type != I_TYPE &&
1258 s->pict_type != P_TYPE){
1259 fprintf(stderr, "invalid picture type\n");
1265 if(s->pict_type == I_TYPE) had_i=1;
1266 if(!had_i) return -1;
1269 s->qscale = get_bits(&s->gb, 5);
1271 fprintf(stderr, "invalid qscale\n");
1275 if (s->pict_type == I_TYPE) {
1276 code = get_bits(&s->gb, 5);
1277 if(s->msmpeg4_version==1){
1278 if(code==0 || code>s->mb_height){
1279 fprintf(stderr, "invalid slice height %d\n", code);
1283 s->slice_height = code;
1285 /* 0x17: one slice, 0x18: two slices, ... */
1287 fprintf(stderr, "error, slice code was %X\n", code);
1291 s->slice_height = s->mb_height / (code - 0x16);
1294 switch(s->msmpeg4_version){
1297 s->rl_chroma_table_index = 2;
1298 s->rl_table_index = 2;
1300 s->dc_table_index = 0; //not used
1303 s->rl_chroma_table_index = decode012(&s->gb);
1304 s->rl_table_index = decode012(&s->gb);
1306 s->dc_table_index = get_bits1(&s->gb);
1309 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1311 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1312 else s->per_mb_rl_table= 0;
1314 if(!s->per_mb_rl_table){
1315 s->rl_chroma_table_index = decode012(&s->gb);
1316 s->rl_table_index = decode012(&s->gb);
1319 s->dc_table_index = get_bits1(&s->gb);
1320 s->inter_intra_pred= 0;
1324 /* printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1326 s->rl_chroma_table_index,
1332 switch(s->msmpeg4_version){
1335 if(s->msmpeg4_version==1)
1336 s->use_skip_mb_code = 1;
1338 s->use_skip_mb_code = get_bits1(&s->gb);
1339 s->rl_table_index = 2;
1340 s->rl_chroma_table_index = s->rl_table_index;
1341 s->dc_table_index = 0; //not used
1342 s->mv_table_index = 0;
1345 s->use_skip_mb_code = get_bits1(&s->gb);
1346 s->rl_table_index = decode012(&s->gb);
1347 s->rl_chroma_table_index = s->rl_table_index;
1349 s->dc_table_index = get_bits1(&s->gb);
1351 s->mv_table_index = get_bits1(&s->gb);
1354 s->use_skip_mb_code = get_bits1(&s->gb);
1356 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1357 else s->per_mb_rl_table= 0;
1359 if(!s->per_mb_rl_table){
1360 s->rl_table_index = decode012(&s->gb);
1361 s->rl_chroma_table_index = s->rl_table_index;
1364 s->dc_table_index = get_bits1(&s->gb);
1366 s->mv_table_index = get_bits1(&s->gb);
1367 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1370 /* printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1371 s->use_skip_mb_code,
1373 s->rl_chroma_table_index,
1378 if(s->flipflop_rounding){
1379 s->no_rounding ^= 1;
1384 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1386 s->esc3_level_length= 0;
1387 s->esc3_run_length= 0;
1390 printf("*****frame %d:\n", frame_count++);
1395 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1397 int left= buf_size*8 - get_bits_count(&s->gb);
1398 int length= s->msmpeg4_version>=3 ? 17 : 16;
1399 /* the alt_bitstream reader could read over the end so we need to check it */
1400 if(left>=length && left<length+8)
1404 fps= get_bits(&s->gb, 5);
1405 s->bit_rate= get_bits(&s->gb, 11)*1024;
1406 if(s->msmpeg4_version>=3)
1407 s->flipflop_rounding= get_bits1(&s->gb);
1409 s->flipflop_rounding= 0;
1411 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1413 else if(left<length+8)
1415 s->flipflop_rounding= 0;
1416 printf("ext header missing, %d left\n", left);
1420 fprintf(stderr, "I frame too long, ignoring ext header\n");
1426 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1433 #ifdef CONFIG_ENCODERS
1435 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1437 int range, bit_size, sign, code, bits;
1442 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1444 bit_size = s->f_code - 1;
1445 range = 1 << bit_size;
1458 code = (val >> bit_size) + 1;
1459 bits = val & (range - 1);
1461 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1463 put_bits(&s->pb, bit_size, bits);
1468 #endif //CONFIG_ENCODERS
1470 /* this is identical to h263 except that its range is multiplied by 2 */
1471 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1473 int code, val, sign, shift;
1475 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1476 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1482 sign = get_bits1(&s->gb);
1484 val = (code - 1) << shift;
1486 val |= get_bits(&s->gb, shift);
1500 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1504 if (s->pict_type == P_TYPE) {
1505 if (s->use_skip_mb_code) {
1506 if (get_bits1(&s->gb)) {
1510 s->block_last_index[i] = -1;
1511 s->mv_dir = MV_DIR_FORWARD;
1512 s->mv_type = MV_TYPE_16X16;
1520 if(s->msmpeg4_version==2)
1521 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1523 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1524 if(code<0 || code>7){
1525 fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1529 s->mb_intra = code >>2;
1534 if(s->msmpeg4_version==2)
1535 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1537 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1539 fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1547 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1549 fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1554 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1556 h263_pred_motion(s, 0, &mx, &my);
1557 mx= msmpeg4v2_decode_motion(s, mx, 1);
1558 my= msmpeg4v2_decode_motion(s, my, 1);
1560 s->mv_dir = MV_DIR_FORWARD;
1561 s->mv_type = MV_TYPE_16X16;
1562 s->mv[0][0][0] = mx;
1563 s->mv[0][0][1] = my;
1565 if(s->msmpeg4_version==2){
1566 s->ac_pred = get_bits1(&s->gb);
1567 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1570 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1571 if(s->pict_type==P_TYPE) cbp^=0x3C;
1575 for (i = 0; i < 6; i++) {
1576 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1578 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1585 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1589 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1591 if (s->pict_type == P_TYPE) {
1592 set_stat(ST_INTER_MB);
1593 if (s->use_skip_mb_code) {
1594 if (get_bits1(&s->gb)) {
1598 s->block_last_index[i] = -1;
1599 s->mv_dir = MV_DIR_FORWARD;
1600 s->mv_type = MV_TYPE_16X16;
1604 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1610 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1613 //s->mb_intra = (code & 0x40) ? 0 : 1;
1614 s->mb_intra = (~code & 0x40) >> 6;
1618 set_stat(ST_INTRA_MB);
1620 code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1623 /* predict coded block pattern */
1626 int val = ((code >> (5 - i)) & 1);
1628 int pred = coded_block_pred(s, i, &coded_val);
1632 cbp |= val << (5 - i);
1638 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1639 if(s->per_mb_rl_table && cbp){
1640 s->rl_table_index = decode012(&s->gb);
1641 s->rl_chroma_table_index = s->rl_table_index;
1644 h263_pred_motion(s, 0, &mx, &my);
1645 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1647 s->mv_dir = MV_DIR_FORWARD;
1648 s->mv_type = MV_TYPE_16X16;
1649 s->mv[0][0][0] = mx;
1650 s->mv[0][0][1] = my;
1651 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1653 //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));
1654 set_stat(ST_INTRA_MB);
1655 s->ac_pred = get_bits1(&s->gb);
1656 *mb_type_ptr = MB_TYPE_INTRA;
1657 if(s->inter_intra_pred){
1658 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1659 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1661 if(s->per_mb_rl_table && cbp){
1662 s->rl_table_index = decode012(&s->gb);
1663 s->rl_chroma_table_index = s->rl_table_index;
1667 for (i = 0; i < 6; i++) {
1668 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1670 fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1677 //#define ERROR_DETAILS
1678 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1679 int n, int coded, const uint8_t *scan_table)
1681 int level, i, last, run, run_diff;
1684 RL_VLC_ELEM *rl_vlc;
1693 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1696 fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1697 if(s->inter_intra_pred) level=0;
1701 rl = &rl_table[s->rl_table_index];
1702 if(level > 256*s->y_dc_scale){
1703 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1704 if(!s->inter_intra_pred) return -1;
1707 rl = &rl_table[3 + s->rl_chroma_table_index];
1708 if(level > 256*s->c_dc_scale){
1709 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1710 if(!s->inter_intra_pred) return -1;
1721 if (dc_pred_dir == 0)
1722 scan_table = s->intra_v_scantable.permutated; /* left */
1724 scan_table = s->intra_h_scantable.permutated; /* top */
1726 scan_table = s->intra_scantable.permutated;
1728 set_stat(ST_INTRA_AC);
1729 rl_vlc= rl->rl_vlc[0];
1731 qmul = s->qscale << 1;
1732 qadd = (s->qscale - 1) | 1;
1734 rl = &rl_table[3 + s->rl_table_index];
1736 if(s->msmpeg4_version==2)
1742 s->block_last_index[n] = i;
1746 scan_table = s->inter_scantable.permutated;
1747 set_stat(ST_INTER_AC);
1748 rl_vlc= rl->rl_vlc[s->qscale];
1751 OPEN_READER(re, &s->gb);
1753 UPDATE_CACHE(re, &s->gb);
1754 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1757 cache= GET_CACHE(re, &s->gb);
1759 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1760 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1762 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1763 UPDATE_CACHE(re, &s->gb);
1764 if(s->msmpeg4_version<=3){
1765 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1766 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1767 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1768 SKIP_COUNTER(re, &s->gb, 1+6+8);
1771 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1772 if(!s->esc3_level_length){
1774 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1776 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1778 if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1779 SKIP_BITS(re, &s->gb, 1);
1784 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1786 SKIP_BITS(re, &s->gb, 1);
1788 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1791 s->esc3_level_length= ll;
1792 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1793 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1794 UPDATE_CACHE(re, &s->gb);
1796 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1797 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1799 sign= SHOW_UBITS(re, &s->gb, 1);
1800 SKIP_BITS(re, &s->gb, 1);
1802 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1803 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1804 if(sign) level= -level;
1806 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1807 #if 0 // waste of time / this will detect very few errors
1809 const int abs_level= ABS(level);
1810 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1811 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1812 if(abs_level <= rl->max_level[last][run]){
1813 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1814 return DECODING_AC_LOST;
1816 if(abs_level <= rl->max_level[last][run]*2){
1817 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1818 return DECODING_AC_LOST;
1820 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1821 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1822 return DECODING_AC_LOST;
1827 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1828 if (level>0) level= level * qmul + qadd;
1829 else level= level * qmul - qadd;
1830 #if 0 // waste of time too :(
1831 if(level>2048 || level<-2048){
1832 fprintf(stderr, "|level| overflow in 3. esc\n");
1833 return DECODING_AC_LOST;
1838 #ifdef ERROR_DETAILS
1840 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1841 else if((i>62 && i<192) || i>192+63)
1842 fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1846 #if MIN_CACHE_BITS < 23
1847 LAST_SKIP_BITS(re, &s->gb, 2);
1848 UPDATE_CACHE(re, &s->gb);
1850 SKIP_BITS(re, &s->gb, 2);
1852 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1853 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1854 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1855 LAST_SKIP_BITS(re, &s->gb, 1);
1856 #ifdef ERROR_DETAILS
1858 fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1859 else if((i>62 && i<192) || i>192+63)
1860 fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1865 #if MIN_CACHE_BITS < 22
1866 LAST_SKIP_BITS(re, &s->gb, 1);
1867 UPDATE_CACHE(re, &s->gb);
1869 SKIP_BITS(re, &s->gb, 1);
1871 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1873 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1874 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1875 LAST_SKIP_BITS(re, &s->gb, 1);
1876 #ifdef ERROR_DETAILS
1878 fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1879 else if((i>62 && i<192) || i>192+63)
1880 fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1885 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1886 LAST_SKIP_BITS(re, &s->gb, 1);
1887 #ifdef ERROR_DETAILS
1889 fprintf(stderr, "illegal vlc code level=%d\n", level);
1890 else if((i>62 && i<192) || i>192+63)
1891 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1897 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1898 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1899 fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1902 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1907 block[scan_table[i]] = level;
1911 block[scan_table[i]] = level;
1913 CLOSE_READER(re, &s->gb);
1917 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1919 i = 63; /* XXX: not optimal */
1922 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1923 s->block_last_index[n] = i;
1928 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1932 if(s->msmpeg4_version<=2){
1934 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1936 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1941 }else{ //FIXME optimize use unified tables & index
1943 level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1945 level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1948 fprintf(stderr, "illegal dc vlc\n");
1952 if (level == DC_MAX) {
1953 level = get_bits(&s->gb, 8);
1954 if (get_bits1(&s->gb))
1956 } else if (level != 0) {
1957 if (get_bits1(&s->gb))
1962 if(s->msmpeg4_version==1){
1964 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1967 /* update predictor */
1971 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1974 /* update predictor */
1976 *dc_val = level * s->y_dc_scale;
1978 *dc_val = level * s->c_dc_scale;
1985 static int msmpeg4_decode_motion(MpegEncContext * s,
1986 int *mx_ptr, int *my_ptr)
1991 mv = &mv_tables[s->mv_table_index];
1993 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1995 fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1998 if (code == mv->n) {
1999 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
2000 mx = get_bits(&s->gb, 6);
2001 my = get_bits(&s->gb, 6);
2003 mx = mv->table_mvx[code];
2004 my = mv->table_mvy[code];
2009 /* WARNING : they do not do exactly modulo encoding */
2024 /* cleanest way to support it
2025 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2026 * as allmost everything would be in the common file