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]);
87 #include "msmpeg4data.h"
89 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
93 const char *st_names[ST_NB] = {
103 int st_current_index = 0;
104 unsigned int st_bit_counts[ST_NB];
105 unsigned int st_out_bit_counts[ST_NB];
107 #define set_stat(var) st_current_index = var;
109 void print_stats(void)
117 total += st_bit_counts[i];
120 for(i=0;i<ST_NB;i++) {
121 printf("%-10s : %10.1f %5.1f%%\n",
123 (double)st_bit_counts[i] / 8.0,
124 (double)st_bit_counts[i] * 100.0 / total);
126 printf("%-10s : %10.1f %5.1f%%\n",
134 total += st_out_bit_counts[i];
137 for(i=0;i<ST_NB;i++) {
138 printf("%-10s : %10.1f %5.1f%%\n",
140 (double)st_out_bit_counts[i] / 8.0,
141 (double)st_out_bit_counts[i] * 100.0 / total);
143 printf("%-10s : %10.1f %5.1f%%\n",
151 #define set_stat(var)
155 static void common_init(MpegEncContext * s)
159 switch(s->msmpeg4_version){
163 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
166 if(s->workaround_bugs){
167 s->y_dc_scale_table= old_ff_y_dc_scale_table;
168 s->c_dc_scale_table= old_ff_c_dc_scale_table;
170 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
171 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
176 s->y_dc_scale_table= wmv1_y_dc_scale_table;
177 s->c_dc_scale_table= wmv1_c_dc_scale_table;
182 if(s->msmpeg4_version>=4){
183 ff_init_scantable(s, &s->intra_scantable , wmv1_scantable[1]);
184 ff_init_scantable(s, &s->intra_h_scantable, wmv1_scantable[2]);
185 ff_init_scantable(s, &s->intra_v_scantable, wmv1_scantable[3]);
186 ff_init_scantable(s, &s->inter_scantable , wmv1_scantable[0]);
188 //Note the default tables are set in common_init in mpegvideo.c
193 init_h263_dc_for_msmpeg4();
197 #ifdef CONFIG_ENCODERS
199 /* build the table which associate a (x,y) motion vector to a vlc */
200 static void init_mv_table(MVTable *tab)
204 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
205 /* mark all entries as not used */
207 tab->table_mv_index[i] = tab->n;
209 for(i=0;i<tab->n;i++) {
210 x = tab->table_mvx[i];
211 y = tab->table_mvy[i];
212 tab->table_mv_index[(x << 6) | y] = i;
216 static void code012(PutBitContext *pb, int n)
222 put_bits(pb, 1, (n >= 2));
226 void ff_msmpeg4_encode_init(MpegEncContext *s)
228 static int init_done=0;
232 if(s->msmpeg4_version>=4){
238 /* init various encoding tables */
240 init_mv_table(&mv_tables[0]);
241 init_mv_table(&mv_tables[1]);
242 for(i=0;i<NB_RL_TABLES;i++)
243 init_rl(&rl_table[i]);
245 for(i=0; i<NB_RL_TABLES; i++){
247 for(level=0; level<=MAX_LEVEL; level++){
249 for(run=0; run<=MAX_RUN; run++){
251 for(last=0; last<2; last++){
252 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
260 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
263 int run_diff= intra ? 0 : 1;
265 code = get_rl_index(rl, last, run, level);
266 size+= rl->table_vlc[code][1];
270 level1 = level - rl->max_level[last][run];
273 code = get_rl_index(rl, last, run, level1);
277 if (level > MAX_LEVEL)
279 run1 = run - rl->max_run[last][level] - run_diff;
282 code = get_rl_index(rl, last, run1, level);
289 size+= 1+1+ rl->table_vlc[code][1];
293 size+= 1+1+ rl->table_vlc[code][1];
301 static void find_best_tables(MpegEncContext * s)
304 int best =-1, best_size =9999999;
305 int chroma_best=-1, best_chroma_size=9999999;
316 for(level=0; level<=MAX_LEVEL; level++){
318 for(run=0; run<=MAX_RUN; run++){
320 const int last_size= size + chroma_size;
321 for(last=0; last<2; last++){
322 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
323 int intra_luma_count = s->ac_stats[1][0][level][run][last];
324 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
326 if(s->pict_type==I_TYPE){
327 size += intra_luma_count *rl_length[i ][level][run][last];
328 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
330 size+= intra_luma_count *rl_length[i ][level][run][last]
331 +intra_chroma_count*rl_length[i+3][level][run][last]
332 +inter_count *rl_length[i+3][level][run][last];
335 if(last_size == size+chroma_size) break;
342 if(chroma_size<best_chroma_size){
343 best_chroma_size= chroma_size;
348 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
349 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
351 if(s->pict_type==P_TYPE) chroma_best= best;
353 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
355 s->rl_table_index = best;
356 s->rl_chroma_table_index= chroma_best;
358 if(s->pict_type != s->last_non_b_pict_type){
359 s->rl_table_index= 2;
360 if(s->pict_type==I_TYPE)
361 s->rl_chroma_table_index= 1;
363 s->rl_chroma_table_index= 2;
368 /* write MSMPEG4 compatible frame header */
369 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
373 align_put_bits(&s->pb);
374 put_bits(&s->pb, 2, s->pict_type - 1);
376 put_bits(&s->pb, 5, s->qscale);
377 if(s->msmpeg4_version<=2){
378 s->rl_table_index = 2;
379 s->rl_chroma_table_index = 2;
382 s->dc_table_index = 1;
383 s->mv_table_index = 1; /* only if P frame */
384 s->use_skip_mb_code = 1; /* only if P frame */
385 s->per_mb_rl_table = 0;
386 if(s->msmpeg4_version==4)
387 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
388 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
390 if (s->pict_type == I_TYPE) {
391 s->slice_height= s->mb_height/1;
392 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
394 if(s->msmpeg4_version==4){
395 msmpeg4_encode_ext_header(s);
396 if(s->bit_rate>MBAC_BITRATE)
397 put_bits(&s->pb, 1, s->per_mb_rl_table);
400 if(s->msmpeg4_version>2){
401 if(!s->per_mb_rl_table){
402 code012(&s->pb, s->rl_chroma_table_index);
403 code012(&s->pb, s->rl_table_index);
406 put_bits(&s->pb, 1, s->dc_table_index);
409 put_bits(&s->pb, 1, s->use_skip_mb_code);
411 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
412 put_bits(&s->pb, 1, s->per_mb_rl_table);
414 if(s->msmpeg4_version>2){
415 if(!s->per_mb_rl_table)
416 code012(&s->pb, s->rl_table_index);
418 put_bits(&s->pb, 1, s->dc_table_index);
420 put_bits(&s->pb, 1, s->mv_table_index);
424 s->esc3_level_length= 0;
425 s->esc3_run_length= 0;
429 printf("*****frame %d:\n", frame_count++);
433 void msmpeg4_encode_ext_header(MpegEncContext * s)
435 put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
437 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
439 if(s->msmpeg4_version>=3)
440 put_bits(&s->pb, 1, s->flipflop_rounding);
442 assert(s->flipflop_rounding==0);
445 #endif //CONFIG_ENCODERS
447 /* predict coded block */
448 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
450 int xy, wrap, pred, a, b, c;
452 xy = s->block_index[n];
453 wrap = s->block_wrap[0];
458 a = s->coded_block[xy - 1 ];
459 b = s->coded_block[xy - 1 - wrap];
460 c = s->coded_block[xy - wrap];
469 *coded_block_ptr = &s->coded_block[xy];
474 #ifdef CONFIG_ENCODERS
476 static void msmpeg4_encode_motion(MpegEncContext * s,
482 /* modulo encoding */
483 /* WARNING : you cannot reach all the MVs even with the modulo
484 encoding. This is a somewhat strange compromise they took !!! */
497 if ((unsigned)mx >= 64 ||
499 fprintf(stderr, "error mx=%d my=%d\n", mx, my);
501 mv = &mv_tables[s->mv_table_index];
503 code = mv->table_mv_index[(mx << 6) | my];
506 mv->table_mv_bits[code],
507 mv->table_mv_code[code]);
509 /* escape : code litterally */
510 put_bits(&s->pb, 6, mx);
511 put_bits(&s->pb, 6, my);
515 static inline void handle_slices(MpegEncContext *s){
517 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
518 if(s->msmpeg4_version < 4){
519 ff_mpeg4_clean_buffers(s);
521 s->first_slice_line = 1;
523 s->first_slice_line = 0;
528 void msmpeg4_encode_mb(MpegEncContext * s,
529 DCTELEM block[6][64],
530 int motion_x, int motion_y)
532 int cbp, coded_cbp, i;
534 uint8_t *coded_block;
540 set_stat(ST_INTER_MB);
542 for (i = 0; i < 6; i++) {
543 if (s->block_last_index[i] >= 0)
546 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
547 /* skip macroblock */
548 put_bits(&s->pb, 1, 1);
555 if (s->use_skip_mb_code)
556 put_bits(&s->pb, 1, 0); /* mb coded */
558 if(s->msmpeg4_version<=2){
560 v2_mb_type[cbp&3][1],
561 v2_mb_type[cbp&3][0]);
562 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
566 cbpy_tab[coded_cbp>>2][1],
567 cbpy_tab[coded_cbp>>2][0]);
569 s->misc_bits += get_bits_diff(s);
571 h263_pred_motion(s, 0, &pred_x, &pred_y);
572 msmpeg4v2_encode_motion(s, motion_x - pred_x);
573 msmpeg4v2_encode_motion(s, motion_y - pred_y);
576 table_mb_non_intra[cbp + 64][1],
577 table_mb_non_intra[cbp + 64][0]);
579 s->misc_bits += get_bits_diff(s);
582 h263_pred_motion(s, 0, &pred_x, &pred_y);
583 msmpeg4_encode_motion(s, motion_x - pred_x,
587 s->mv_bits += get_bits_diff(s);
589 for (i = 0; i < 6; i++) {
590 msmpeg4_encode_block(s, block[i], i);
592 s->p_tex_bits += get_bits_diff(s);
597 for (i = 0; i < 6; i++) {
599 val = (s->block_last_index[i] >= 1);
600 cbp |= val << (5 - i);
602 /* predict value for close blocks only for luma */
603 pred = coded_block_pred(s, i, &coded_block);
607 coded_cbp |= val << (5 - i);
611 printf("cbp=%x %x\n", cbp, coded_cbp);
614 if(s->msmpeg4_version<=2){
615 if (s->pict_type == I_TYPE) {
617 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
619 if (s->use_skip_mb_code)
620 put_bits(&s->pb, 1, 0); /* mb coded */
622 v2_mb_type[(cbp&3) + 4][1],
623 v2_mb_type[(cbp&3) + 4][0]);
625 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
628 cbpy_tab[cbp>>2][0]);
630 if (s->pict_type == I_TYPE) {
631 set_stat(ST_INTRA_MB);
633 table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
635 if (s->use_skip_mb_code)
636 put_bits(&s->pb, 1, 0); /* mb coded */
638 table_mb_non_intra[cbp][1],
639 table_mb_non_intra[cbp][0]);
641 set_stat(ST_INTRA_MB);
642 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
643 if(s->inter_intra_pred){
645 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
648 s->misc_bits += get_bits_diff(s);
650 for (i = 0; i < 6; i++) {
651 msmpeg4_encode_block(s, block[i], i);
653 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 FASTDIV((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 = FASTDIV((a + (scale >> 1)), scale);
765 b = FASTDIV((b + (scale >> 1)), scale);
766 c = FASTDIV((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);
1484 val = (val - 1) << shift;
1485 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