2 * MSMPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
25 * MSMPEG4 backend for ffmpeg encoder and decoder.
30 #include "mpegvideo.h"
33 * You can also call this codec : MPEG4 with a twist !
36 * - (encoding) select best mv table (two choices)
37 * - (encoding) select best vlc/dc table
42 #define CBPY_VLC_BITS 6
43 #define INTER_INTRA_VLC_BITS 3
44 #define V1_INTRA_CBPC_VLC_BITS 6
45 #define V1_INTER_CBPC_VLC_BITS 6
46 #define V2_INTRA_CBPC_VLC_BITS 3
47 #define V2_MB_TYPE_VLC_BITS 7
49 #define V2_MV_VLC_BITS 9
50 #define TEX_VLC_BITS 9
51 #define MB_NON_INTRA_VLC_BITS 9
52 #define MB_INTRA_VLC_BITS 9
54 #define II_BITRATE 128*1024
55 #define MBAC_BITRATE 50*1024
57 #define DEFAULT_INTER_INDEX 3
59 static uint32_t v2_dc_lum_table[512][2];
60 static uint32_t v2_dc_chroma_table[512][2];
62 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
63 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
64 int n, int coded, const uint8_t *scantable);
65 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
66 static int msmpeg4_decode_motion(MpegEncContext * s,
67 int *mx_ptr, int *my_ptr);
68 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
69 static void init_h263_dc_for_msmpeg4(void);
70 static inline void msmpeg4_memsetw(short *tab, int val, int n);
71 #ifdef CONFIG_ENCODERS
72 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
73 #endif //CONFIG_ENCODERS
74 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
76 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
79 extern uint8_t wmv3_dc_scale_table[32];
86 #include "msmpeg4data.h"
88 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
89 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
90 #endif //CONFIG_ENCODERS
94 const char *st_names[ST_NB] = {
104 int st_current_index = 0;
105 unsigned int st_bit_counts[ST_NB];
106 unsigned int st_out_bit_counts[ST_NB];
108 #define set_stat(var) st_current_index = var;
110 void print_stats(void)
118 total += st_bit_counts[i];
121 for(i=0;i<ST_NB;i++) {
122 printf("%-10s : %10.1f %5.1f%%\n",
124 (double)st_bit_counts[i] / 8.0,
125 (double)st_bit_counts[i] * 100.0 / total);
127 printf("%-10s : %10.1f %5.1f%%\n",
135 total += st_out_bit_counts[i];
138 for(i=0;i<ST_NB;i++) {
139 printf("%-10s : %10.1f %5.1f%%\n",
141 (double)st_out_bit_counts[i] / 8.0,
142 (double)st_out_bit_counts[i] * 100.0 / total);
144 printf("%-10s : %10.1f %5.1f%%\n",
152 #define set_stat(var)
156 static void common_init(MpegEncContext * s)
160 switch(s->msmpeg4_version){
164 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
167 if(s->workaround_bugs){
168 s->y_dc_scale_table= old_ff_y_dc_scale_table;
169 s->c_dc_scale_table= old_ff_c_dc_scale_table;
171 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
172 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
177 s->y_dc_scale_table= wmv1_y_dc_scale_table;
178 s->c_dc_scale_table= wmv1_c_dc_scale_table;
181 s->y_dc_scale_table= wmv3_dc_scale_table;
182 s->c_dc_scale_table= wmv3_dc_scale_table;
188 if(s->msmpeg4_version>=4){
189 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
190 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
191 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
192 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
194 //Note the default tables are set in common_init in mpegvideo.c
199 init_h263_dc_for_msmpeg4();
203 #ifdef CONFIG_ENCODERS
205 /* build the table which associate a (x,y) motion vector to a vlc */
206 static void init_mv_table(MVTable *tab)
210 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
211 /* mark all entries as not used */
213 tab->table_mv_index[i] = tab->n;
215 for(i=0;i<tab->n;i++) {
216 x = tab->table_mvx[i];
217 y = tab->table_mvy[i];
218 tab->table_mv_index[(x << 6) | y] = i;
222 static void code012(PutBitContext *pb, int n)
228 put_bits(pb, 1, (n >= 2));
232 void ff_msmpeg4_encode_init(MpegEncContext *s)
234 static int init_done=0;
238 if(s->msmpeg4_version>=4){
244 /* init various encoding tables */
246 init_mv_table(&mv_tables[0]);
247 init_mv_table(&mv_tables[1]);
248 for(i=0;i<NB_RL_TABLES;i++)
249 init_rl(&rl_table[i], 1);
251 for(i=0; i<NB_RL_TABLES; i++){
253 for(level=0; level<=MAX_LEVEL; level++){
255 for(run=0; run<=MAX_RUN; run++){
257 for(last=0; last<2; last++){
258 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
266 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
269 int run_diff= intra ? 0 : 1;
271 code = get_rl_index(rl, last, run, level);
272 size+= rl->table_vlc[code][1];
276 level1 = level - rl->max_level[last][run];
279 code = get_rl_index(rl, last, run, level1);
283 if (level > MAX_LEVEL)
285 run1 = run - rl->max_run[last][level] - run_diff;
288 code = get_rl_index(rl, last, run1, level);
295 size+= 1+1+ rl->table_vlc[code][1];
299 size+= 1+1+ rl->table_vlc[code][1];
307 static void find_best_tables(MpegEncContext * s)
310 int best =-1, best_size =9999999;
311 int chroma_best=-1, best_chroma_size=9999999;
322 for(level=0; level<=MAX_LEVEL; level++){
324 for(run=0; run<=MAX_RUN; run++){
326 const int last_size= size + chroma_size;
327 for(last=0; last<2; last++){
328 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
329 int intra_luma_count = s->ac_stats[1][0][level][run][last];
330 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
332 if(s->pict_type==I_TYPE){
333 size += intra_luma_count *rl_length[i ][level][run][last];
334 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
336 size+= intra_luma_count *rl_length[i ][level][run][last]
337 +intra_chroma_count*rl_length[i+3][level][run][last]
338 +inter_count *rl_length[i+3][level][run][last];
341 if(last_size == size+chroma_size) break;
348 if(chroma_size<best_chroma_size){
349 best_chroma_size= chroma_size;
354 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
355 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
357 if(s->pict_type==P_TYPE) chroma_best= best;
359 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
361 s->rl_table_index = best;
362 s->rl_chroma_table_index= chroma_best;
364 if(s->pict_type != s->last_non_b_pict_type){
365 s->rl_table_index= 2;
366 if(s->pict_type==I_TYPE)
367 s->rl_chroma_table_index= 1;
369 s->rl_chroma_table_index= 2;
374 /* write MSMPEG4 compatible frame header */
375 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
379 align_put_bits(&s->pb);
380 put_bits(&s->pb, 2, s->pict_type - 1);
382 put_bits(&s->pb, 5, s->qscale);
383 if(s->msmpeg4_version<=2){
384 s->rl_table_index = 2;
385 s->rl_chroma_table_index = 2;
388 s->dc_table_index = 1;
389 s->mv_table_index = 1; /* only if P frame */
390 s->use_skip_mb_code = 1; /* only if P frame */
391 s->per_mb_rl_table = 0;
392 if(s->msmpeg4_version==4)
393 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
394 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
396 if (s->pict_type == I_TYPE) {
397 s->slice_height= s->mb_height/1;
398 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
400 if(s->msmpeg4_version==4){
401 msmpeg4_encode_ext_header(s);
402 if(s->bit_rate>MBAC_BITRATE)
403 put_bits(&s->pb, 1, s->per_mb_rl_table);
406 if(s->msmpeg4_version>2){
407 if(!s->per_mb_rl_table){
408 code012(&s->pb, s->rl_chroma_table_index);
409 code012(&s->pb, s->rl_table_index);
412 put_bits(&s->pb, 1, s->dc_table_index);
415 put_bits(&s->pb, 1, s->use_skip_mb_code);
417 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
418 put_bits(&s->pb, 1, s->per_mb_rl_table);
420 if(s->msmpeg4_version>2){
421 if(!s->per_mb_rl_table)
422 code012(&s->pb, s->rl_table_index);
424 put_bits(&s->pb, 1, s->dc_table_index);
426 put_bits(&s->pb, 1, s->mv_table_index);
430 s->esc3_level_length= 0;
431 s->esc3_run_length= 0;
435 printf("*****frame %d:\n", frame_count++);
439 void msmpeg4_encode_ext_header(MpegEncContext * s)
441 put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
443 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
445 if(s->msmpeg4_version>=3)
446 put_bits(&s->pb, 1, s->flipflop_rounding);
448 assert(s->flipflop_rounding==0);
451 #endif //CONFIG_ENCODERS
453 /* predict coded block */
454 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
456 int xy, wrap, pred, a, b, c;
458 xy = s->block_index[n];
464 a = s->coded_block[xy - 1 ];
465 b = s->coded_block[xy - 1 - wrap];
466 c = s->coded_block[xy - wrap];
475 *coded_block_ptr = &s->coded_block[xy];
480 #ifdef CONFIG_ENCODERS
482 static void msmpeg4_encode_motion(MpegEncContext * s,
488 /* modulo encoding */
489 /* WARNING : you cannot reach all the MVs even with the modulo
490 encoding. This is a somewhat strange compromise they took !!! */
503 if ((unsigned)mx >= 64 ||
505 fprintf(stderr, "error mx=%d my=%d\n", mx, my);
507 mv = &mv_tables[s->mv_table_index];
509 code = mv->table_mv_index[(mx << 6) | my];
512 mv->table_mv_bits[code],
513 mv->table_mv_code[code]);
515 /* escape : code litterally */
516 put_bits(&s->pb, 6, mx);
517 put_bits(&s->pb, 6, my);
521 static inline void handle_slices(MpegEncContext *s){
523 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
524 if(s->msmpeg4_version < 4){
525 ff_mpeg4_clean_buffers(s);
527 s->first_slice_line = 1;
529 s->first_slice_line = 0;
534 void msmpeg4_encode_mb(MpegEncContext * s,
535 DCTELEM block[6][64],
536 int motion_x, int motion_y)
538 int cbp, coded_cbp, i;
540 uint8_t *coded_block;
546 set_stat(ST_INTER_MB);
548 for (i = 0; i < 6; i++) {
549 if (s->block_last_index[i] >= 0)
552 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
553 /* skip macroblock */
554 put_bits(&s->pb, 1, 1);
561 if (s->use_skip_mb_code)
562 put_bits(&s->pb, 1, 0); /* mb coded */
564 if(s->msmpeg4_version<=2){
566 v2_mb_type[cbp&3][1],
567 v2_mb_type[cbp&3][0]);
568 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
572 cbpy_tab[coded_cbp>>2][1],
573 cbpy_tab[coded_cbp>>2][0]);
575 s->misc_bits += get_bits_diff(s);
577 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
578 msmpeg4v2_encode_motion(s, motion_x - pred_x);
579 msmpeg4v2_encode_motion(s, motion_y - pred_y);
582 table_mb_non_intra[cbp + 64][1],
583 table_mb_non_intra[cbp + 64][0]);
585 s->misc_bits += get_bits_diff(s);
588 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
589 msmpeg4_encode_motion(s, motion_x - pred_x,
593 s->mv_bits += get_bits_diff(s);
595 for (i = 0; i < 6; i++) {
596 msmpeg4_encode_block(s, block[i], i);
598 s->p_tex_bits += get_bits_diff(s);
603 for (i = 0; i < 6; i++) {
605 val = (s->block_last_index[i] >= 1);
606 cbp |= val << (5 - i);
608 /* predict value for close blocks only for luma */
609 pred = coded_block_pred(s, i, &coded_block);
613 coded_cbp |= val << (5 - i);
617 printf("cbp=%x %x\n", cbp, coded_cbp);
620 if(s->msmpeg4_version<=2){
621 if (s->pict_type == I_TYPE) {
623 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
625 if (s->use_skip_mb_code)
626 put_bits(&s->pb, 1, 0); /* mb coded */
628 v2_mb_type[(cbp&3) + 4][1],
629 v2_mb_type[(cbp&3) + 4][0]);
631 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
634 cbpy_tab[cbp>>2][0]);
636 if (s->pict_type == I_TYPE) {
637 set_stat(ST_INTRA_MB);
639 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
641 if (s->use_skip_mb_code)
642 put_bits(&s->pb, 1, 0); /* mb coded */
644 table_mb_non_intra[cbp][1],
645 table_mb_non_intra[cbp][0]);
647 set_stat(ST_INTRA_MB);
648 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
649 if(s->inter_intra_pred){
651 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
654 s->misc_bits += get_bits_diff(s);
656 for (i = 0; i < 6; i++) {
657 msmpeg4_encode_block(s, block[i], i);
659 s->i_tex_bits += get_bits_diff(s);
664 #endif //CONFIG_ENCODERS
666 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
667 int32_t **dc_val_ptr)
677 *dc_val_ptr= &s->last_dc[i];
678 return s->last_dc[i];
681 static int get_dc(uint8_t *src, int stride, int scale)
688 sum+=src[x + y*stride];
691 return FASTDIV((sum + (scale>>1)), scale);
694 /* dir = 0: left, dir = 1: top prediction */
695 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
696 uint16_t **dc_val_ptr, int *dir_ptr)
698 int a, b, c, wrap, pred, scale;
701 /* find prediction */
703 scale = s->y_dc_scale;
705 scale = s->c_dc_scale;
708 wrap = s->block_wrap[n];
709 dc_val= s->dc_val[0] + s->block_index[n];
715 b = dc_val[ - 1 - wrap];
718 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
722 /* XXX: the following solution consumes divisions, but it does not
723 necessitate to modify mpegvideo.c. The problem comes from the
724 fact they decided to store the quantized DC (which would lead
725 to problems if Q could vary !) */
726 #if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined PIC
728 "movl %3, %%eax \n\t"
729 "shrl $1, %%eax \n\t"
730 "addl %%eax, %2 \n\t"
731 "addl %%eax, %1 \n\t"
732 "addl %0, %%eax \n\t"
734 "movl %%edx, %0 \n\t"
735 "movl %1, %%eax \n\t"
737 "movl %%edx, %1 \n\t"
738 "movl %2, %%eax \n\t"
740 "movl %%edx, %2 \n\t"
741 : "+b" (a), "+c" (b), "+D" (c)
742 : "g" (scale), "S" (inverse[scale])
746 /* #elif defined (ARCH_ALPHA) */
747 /* Divisions are extremely costly on Alpha; optimize the most
748 common case. But they are costly everywhere...
751 a = (a + (8 >> 1)) / 8;
752 b = (b + (8 >> 1)) / 8;
753 c = (c + (8 >> 1)) / 8;
755 a = FASTDIV((a + (scale >> 1)), scale);
756 b = FASTDIV((b + (scale >> 1)), scale);
757 c = FASTDIV((c + (scale >> 1)), scale);
760 /* XXX: WARNING: they did not choose the same test as MPEG4. This
761 is very important ! */
762 if(s->msmpeg4_version>3){
763 if(s->inter_intra_pred){
774 if (abs(a - b) < abs(b - c)) {
784 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
787 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
789 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
790 else a= get_dc(dest-8, wrap, scale*8);
791 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
792 else c= get_dc(dest-8*wrap, wrap, scale*8);
794 if (s->h263_aic_dir==0) {
797 }else if (s->h263_aic_dir==1) {
805 }else if (s->h263_aic_dir==2) {
819 if (abs(a - b) < abs(b - c)) {
828 if (abs(a - b) <= abs(b - c)) {
837 /* update predictor */
838 *dc_val_ptr = &dc_val[0];
844 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
849 if(s->msmpeg4_version==1){
851 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
853 /* update predictor */
857 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
859 /* update predictor */
861 *dc_val = level * s->y_dc_scale;
863 *dc_val = level * s->c_dc_scale;
867 /* do the prediction */
870 if(s->msmpeg4_version<=2){
873 v2_dc_lum_table[level+256][1],
874 v2_dc_lum_table[level+256][0]);
877 v2_dc_chroma_table[level+256][1],
878 v2_dc_chroma_table[level+256][0]);
890 if (s->dc_table_index == 0) {
892 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
894 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
898 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
900 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
905 put_bits(&s->pb, 8, level);
908 put_bits(&s->pb, 1, sign);
913 /* Encoding of a block. Very similar to MPEG4 except for a different
914 escape coding (same as H263) and more vlc tables.
916 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
918 int level, run, last, i, j, last_index;
919 int last_non_zero, sign, slevel;
920 int code, run_diff, dc_pred_dir;
922 const uint8_t *scantable;
926 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
929 rl = &rl_table[s->rl_table_index];
931 rl = &rl_table[3 + s->rl_chroma_table_index];
934 scantable= s->intra_scantable.permutated;
935 set_stat(ST_INTRA_AC);
938 rl = &rl_table[3 + s->rl_table_index];
939 if(s->msmpeg4_version<=2)
943 scantable= s->inter_scantable.permutated;
944 set_stat(ST_INTER_AC);
947 /* recalculate block_last_index for M$ wmv1 */
948 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
949 for(last_index=63; last_index>=0; last_index--){
950 if(block[scantable[last_index]]) break;
952 s->block_last_index[n]= last_index;
954 last_index = s->block_last_index[n];
956 last_non_zero = i - 1;
957 for (; i <= last_index; i++) {
961 run = i - last_non_zero - 1;
962 last = (i == last_index);
970 if(level<=MAX_LEVEL && run<=MAX_RUN){
971 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
975 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
977 code = get_rl_index(rl, last, run, level);
978 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
982 level1 = level - rl->max_level[last][run];
985 code = get_rl_index(rl, last, run, level1);
988 put_bits(&s->pb, 1, 0);
989 if (level > MAX_LEVEL)
991 run1 = run - rl->max_run[last][level] - run_diff;
994 code = get_rl_index(rl, last, run1, level);
998 put_bits(&s->pb, 1, 0);
999 put_bits(&s->pb, 1, last);
1000 if(s->msmpeg4_version>=4){
1001 if(s->esc3_level_length==0){
1002 s->esc3_level_length=8;
1003 s->esc3_run_length= 6;
1005 put_bits(&s->pb, 6, 3);
1007 put_bits(&s->pb, 8, 3);
1009 put_bits(&s->pb, s->esc3_run_length, run);
1010 put_bits(&s->pb, 1, sign);
1011 put_bits(&s->pb, s->esc3_level_length, level);
1013 put_bits(&s->pb, 6, run);
1014 put_bits(&s->pb, 8, slevel & 0xff);
1018 put_bits(&s->pb, 1, 1);
1019 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1020 put_bits(&s->pb, 1, sign);
1024 put_bits(&s->pb, 1, 1);
1025 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1026 put_bits(&s->pb, 1, sign);
1029 put_bits(&s->pb, 1, sign);
1036 /****************************************/
1037 /* decoding stuff */
1039 static VLC mb_non_intra_vlc[4];
1040 VLC ff_msmp4_mb_i_vlc;
1041 VLC ff_msmp4_dc_luma_vlc[2];
1042 VLC ff_msmp4_dc_chroma_vlc[2];
1043 static VLC v2_dc_lum_vlc;
1044 static VLC v2_dc_chroma_vlc;
1045 static VLC cbpy_vlc;
1046 static VLC v2_intra_cbpc_vlc;
1047 static VLC v2_mb_type_vlc;
1048 static VLC v2_mv_vlc;
1049 static VLC v1_intra_cbpc_vlc;
1050 static VLC v1_inter_cbpc_vlc;
1051 static VLC inter_intra_vlc;
1053 /* this table is practically identical to the one from h263 except that its inverted */
1054 static void init_h263_dc_for_msmpeg4(void)
1056 int level, uni_code, uni_len;
1058 for(level=-256; level<256; level++){
1060 /* find number of bits */
1069 l= (-level) ^ ((1 << size) - 1);
1073 /* luminance h263 */
1074 uni_code= DCtab_lum[size][0];
1075 uni_len = DCtab_lum[size][1];
1076 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1079 uni_code<<=size; uni_code|=l;
1082 uni_code<<=1; uni_code|=1;
1086 v2_dc_lum_table[level+256][0]= uni_code;
1087 v2_dc_lum_table[level+256][1]= uni_len;
1089 /* chrominance h263 */
1090 uni_code= DCtab_chrom[size][0];
1091 uni_len = DCtab_chrom[size][1];
1092 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1095 uni_code<<=size; uni_code|=l;
1098 uni_code<<=1; uni_code|=1;
1102 v2_dc_chroma_table[level+256][0]= uni_code;
1103 v2_dc_chroma_table[level+256][1]= uni_len;
1108 /* init all vlc decoding tables */
1109 int ff_msmpeg4_decode_init(MpegEncContext *s)
1111 static int done = 0;
1120 for(i=0;i<NB_RL_TABLES;i++) {
1121 init_rl(&rl_table[i], 1);
1122 init_vlc_rl(&rl_table[i], 1);
1126 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1127 mv->table_mv_bits, 1, 1,
1128 mv->table_mv_code, 2, 2, 1);
1131 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1132 &ff_table0_dc_lum[0][1], 8, 4,
1133 &ff_table0_dc_lum[0][0], 8, 4, 1);
1134 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1135 &ff_table0_dc_chroma[0][1], 8, 4,
1136 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1137 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1138 &ff_table1_dc_lum[0][1], 8, 4,
1139 &ff_table1_dc_lum[0][0], 8, 4, 1);
1140 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1141 &ff_table1_dc_chroma[0][1], 8, 4,
1142 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1144 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1145 &v2_dc_lum_table[0][1], 8, 4,
1146 &v2_dc_lum_table[0][0], 8, 4, 1);
1147 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1148 &v2_dc_chroma_table[0][1], 8, 4,
1149 &v2_dc_chroma_table[0][0], 8, 4, 1);
1151 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1152 &cbpy_tab[0][1], 2, 1,
1153 &cbpy_tab[0][0], 2, 1, 1);
1154 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1155 &v2_intra_cbpc[0][1], 2, 1,
1156 &v2_intra_cbpc[0][0], 2, 1, 1);
1157 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1158 &v2_mb_type[0][1], 2, 1,
1159 &v2_mb_type[0][0], 2, 1, 1);
1160 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1162 &mvtab[0][0], 2, 1, 1);
1165 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1166 &wmv2_inter_table[i][0][1], 8, 4,
1167 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1170 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1171 &ff_msmp4_mb_i_table[0][1], 4, 2,
1172 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1174 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1175 intra_MCBPC_bits, 1, 1,
1176 intra_MCBPC_code, 1, 1, 1);
1177 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1178 inter_MCBPC_bits, 1, 1,
1179 inter_MCBPC_code, 1, 1, 1);
1181 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1182 &table_inter_intra[0][1], 2, 1,
1183 &table_inter_intra[0][0], 2, 1, 1);
1186 switch(s->msmpeg4_version){
1189 s->decode_mb= msmpeg4v12_decode_mb;
1193 s->decode_mb= msmpeg4v34_decode_mb;
1196 s->decode_mb= wmv2_decode_mb;
1198 //FIXME + TODO VC9 decode mb
1202 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1207 int msmpeg4_decode_picture_header(MpegEncContext * s)
1214 for(i=0; i<s->gb.size_in_bits; i++)
1215 printf("%d", get_bits1(&s->gb));
1216 // get_bits1(&s->gb);
1222 if(s->msmpeg4_version==1){
1223 int start_code, num;
1224 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1225 if(start_code!=0x00000100){
1226 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1230 num= get_bits(&s->gb, 5); // frame number */
1233 s->pict_type = get_bits(&s->gb, 2) + 1;
1234 if (s->pict_type != I_TYPE &&
1235 s->pict_type != P_TYPE){
1236 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1242 if(s->pict_type == I_TYPE) had_i=1;
1243 if(!had_i) return -1;
1246 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1248 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1252 if (s->pict_type == I_TYPE) {
1253 code = get_bits(&s->gb, 5);
1254 if(s->msmpeg4_version==1){
1255 if(code==0 || code>s->mb_height){
1256 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1260 s->slice_height = code;
1262 /* 0x17: one slice, 0x18: two slices, ... */
1264 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1268 s->slice_height = s->mb_height / (code - 0x16);
1271 switch(s->msmpeg4_version){
1274 s->rl_chroma_table_index = 2;
1275 s->rl_table_index = 2;
1277 s->dc_table_index = 0; //not used
1280 s->rl_chroma_table_index = decode012(&s->gb);
1281 s->rl_table_index = decode012(&s->gb);
1283 s->dc_table_index = get_bits1(&s->gb);
1286 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1288 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1289 else s->per_mb_rl_table= 0;
1291 if(!s->per_mb_rl_table){
1292 s->rl_chroma_table_index = decode012(&s->gb);
1293 s->rl_table_index = decode012(&s->gb);
1296 s->dc_table_index = get_bits1(&s->gb);
1297 s->inter_intra_pred= 0;
1301 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1302 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1304 s->rl_chroma_table_index,
1310 switch(s->msmpeg4_version){
1313 if(s->msmpeg4_version==1)
1314 s->use_skip_mb_code = 1;
1316 s->use_skip_mb_code = get_bits1(&s->gb);
1317 s->rl_table_index = 2;
1318 s->rl_chroma_table_index = s->rl_table_index;
1319 s->dc_table_index = 0; //not used
1320 s->mv_table_index = 0;
1323 s->use_skip_mb_code = get_bits1(&s->gb);
1324 s->rl_table_index = decode012(&s->gb);
1325 s->rl_chroma_table_index = s->rl_table_index;
1327 s->dc_table_index = get_bits1(&s->gb);
1329 s->mv_table_index = get_bits1(&s->gb);
1332 s->use_skip_mb_code = get_bits1(&s->gb);
1334 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1335 else s->per_mb_rl_table= 0;
1337 if(!s->per_mb_rl_table){
1338 s->rl_table_index = decode012(&s->gb);
1339 s->rl_chroma_table_index = s->rl_table_index;
1342 s->dc_table_index = get_bits1(&s->gb);
1344 s->mv_table_index = get_bits1(&s->gb);
1345 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1349 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1350 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1351 s->use_skip_mb_code,
1353 s->rl_chroma_table_index,
1359 if(s->flipflop_rounding){
1360 s->no_rounding ^= 1;
1365 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1367 s->esc3_level_length= 0;
1368 s->esc3_run_length= 0;
1371 printf("*****frame %d:\n", frame_count++);
1376 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1378 int left= buf_size*8 - get_bits_count(&s->gb);
1379 int length= s->msmpeg4_version>=3 ? 17 : 16;
1380 /* the alt_bitstream reader could read over the end so we need to check it */
1381 if(left>=length && left<length+8)
1385 fps= get_bits(&s->gb, 5);
1386 s->bit_rate= get_bits(&s->gb, 11)*1024;
1387 if(s->msmpeg4_version>=3)
1388 s->flipflop_rounding= get_bits1(&s->gb);
1390 s->flipflop_rounding= 0;
1392 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1394 else if(left<length+8)
1396 s->flipflop_rounding= 0;
1397 if(s->msmpeg4_version != 2)
1398 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1402 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1408 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1415 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1417 int range, bit_size, sign, code, bits;
1422 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1424 bit_size = s->f_code - 1;
1425 range = 1 << bit_size;
1438 code = (val >> bit_size) + 1;
1439 bits = val & (range - 1);
1441 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1443 put_bits(&s->pb, bit_size, bits);
1448 /* this is identical to h263 except that its range is multiplied by 2 */
1449 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1451 int code, val, sign, shift;
1453 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1454 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1460 sign = get_bits1(&s->gb);
1464 val = (val - 1) << shift;
1465 val |= get_bits(&s->gb, shift);
1480 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1484 if (s->pict_type == P_TYPE) {
1485 if (s->use_skip_mb_code) {
1486 if (get_bits1(&s->gb)) {
1490 s->block_last_index[i] = -1;
1491 s->mv_dir = MV_DIR_FORWARD;
1492 s->mv_type = MV_TYPE_16X16;
1500 if(s->msmpeg4_version==2)
1501 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1503 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1504 if(code<0 || code>7){
1505 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1509 s->mb_intra = code >>2;
1514 if(s->msmpeg4_version==2)
1515 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1517 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1519 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1527 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1529 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1534 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1536 h263_pred_motion(s, 0, 0, &mx, &my);
1537 mx= msmpeg4v2_decode_motion(s, mx, 1);
1538 my= msmpeg4v2_decode_motion(s, my, 1);
1540 s->mv_dir = MV_DIR_FORWARD;
1541 s->mv_type = MV_TYPE_16X16;
1542 s->mv[0][0][0] = mx;
1543 s->mv[0][0][1] = my;
1545 if(s->msmpeg4_version==2){
1546 s->ac_pred = get_bits1(&s->gb);
1547 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1550 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1551 if(s->pict_type==P_TYPE) cbp^=0x3C;
1555 for (i = 0; i < 6; i++) {
1556 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1558 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1565 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1569 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1571 if (s->pict_type == P_TYPE) {
1572 set_stat(ST_INTER_MB);
1573 if (s->use_skip_mb_code) {
1574 if (get_bits1(&s->gb)) {
1578 s->block_last_index[i] = -1;
1579 s->mv_dir = MV_DIR_FORWARD;
1580 s->mv_type = MV_TYPE_16X16;
1584 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1590 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1593 //s->mb_intra = (code & 0x40) ? 0 : 1;
1594 s->mb_intra = (~code & 0x40) >> 6;
1598 set_stat(ST_INTRA_MB);
1600 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1603 /* predict coded block pattern */
1606 int val = ((code >> (5 - i)) & 1);
1608 int pred = coded_block_pred(s, i, &coded_val);
1612 cbp |= val << (5 - i);
1618 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1619 if(s->per_mb_rl_table && cbp){
1620 s->rl_table_index = decode012(&s->gb);
1621 s->rl_chroma_table_index = s->rl_table_index;
1624 h263_pred_motion(s, 0, 0, &mx, &my);
1625 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1627 s->mv_dir = MV_DIR_FORWARD;
1628 s->mv_type = MV_TYPE_16X16;
1629 s->mv[0][0][0] = mx;
1630 s->mv[0][0][1] = my;
1631 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1633 //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));
1634 set_stat(ST_INTRA_MB);
1635 s->ac_pred = get_bits1(&s->gb);
1636 *mb_type_ptr = MB_TYPE_INTRA;
1637 if(s->inter_intra_pred){
1638 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1639 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1641 if(s->per_mb_rl_table && cbp){
1642 s->rl_table_index = decode012(&s->gb);
1643 s->rl_chroma_table_index = s->rl_table_index;
1647 for (i = 0; i < 6; i++) {
1648 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1650 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1657 //#define ERROR_DETAILS
1658 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1659 int n, int coded, const uint8_t *scan_table)
1661 int level, i, last, run, run_diff;
1664 RL_VLC_ELEM *rl_vlc;
1673 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1676 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1677 if(s->inter_intra_pred) level=0;
1681 rl = &rl_table[s->rl_table_index];
1682 if(level > 256*s->y_dc_scale){
1683 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1684 if(!s->inter_intra_pred) return -1;
1687 rl = &rl_table[3 + s->rl_chroma_table_index];
1688 if(level > 256*s->c_dc_scale){
1689 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1690 if(!s->inter_intra_pred) return -1;
1701 if (dc_pred_dir == 0)
1702 scan_table = s->intra_v_scantable.permutated; /* left */
1704 scan_table = s->intra_h_scantable.permutated; /* top */
1706 scan_table = s->intra_scantable.permutated;
1708 set_stat(ST_INTRA_AC);
1709 rl_vlc= rl->rl_vlc[0];
1711 qmul = s->qscale << 1;
1712 qadd = (s->qscale - 1) | 1;
1714 rl = &rl_table[3 + s->rl_table_index];
1716 if(s->msmpeg4_version==2)
1722 s->block_last_index[n] = i;
1726 scan_table = s->inter_scantable.permutated;
1727 set_stat(ST_INTER_AC);
1728 rl_vlc= rl->rl_vlc[s->qscale];
1731 OPEN_READER(re, &s->gb);
1733 UPDATE_CACHE(re, &s->gb);
1734 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1737 cache= GET_CACHE(re, &s->gb);
1739 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1740 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1742 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1743 UPDATE_CACHE(re, &s->gb);
1744 if(s->msmpeg4_version<=3){
1745 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1746 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1747 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1748 SKIP_COUNTER(re, &s->gb, 1+6+8);
1751 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1752 if(!s->esc3_level_length){
1754 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1756 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1758 if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1759 SKIP_BITS(re, &s->gb, 1);
1764 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1766 SKIP_BITS(re, &s->gb, 1);
1768 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1771 s->esc3_level_length= ll;
1772 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1773 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1774 UPDATE_CACHE(re, &s->gb);
1776 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1777 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1779 sign= SHOW_UBITS(re, &s->gb, 1);
1780 SKIP_BITS(re, &s->gb, 1);
1782 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1783 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1784 if(sign) level= -level;
1786 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1787 #if 0 // waste of time / this will detect very few errors
1789 const int abs_level= ABS(level);
1790 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1791 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1792 if(abs_level <= rl->max_level[last][run]){
1793 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1794 return DECODING_AC_LOST;
1796 if(abs_level <= rl->max_level[last][run]*2){
1797 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1798 return DECODING_AC_LOST;
1800 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1801 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1802 return DECODING_AC_LOST;
1807 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1808 if (level>0) level= level * qmul + qadd;
1809 else level= level * qmul - qadd;
1810 #if 0 // waste of time too :(
1811 if(level>2048 || level<-2048){
1812 fprintf(stderr, "|level| overflow in 3. esc\n");
1813 return DECODING_AC_LOST;
1818 #ifdef ERROR_DETAILS
1820 fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1821 else if((i>62 && i<192) || i>192+63)
1822 fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1826 #if MIN_CACHE_BITS < 23
1827 LAST_SKIP_BITS(re, &s->gb, 2);
1828 UPDATE_CACHE(re, &s->gb);
1830 SKIP_BITS(re, &s->gb, 2);
1832 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1833 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1834 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1835 LAST_SKIP_BITS(re, &s->gb, 1);
1836 #ifdef ERROR_DETAILS
1838 fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1839 else if((i>62 && i<192) || i>192+63)
1840 fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1845 #if MIN_CACHE_BITS < 22
1846 LAST_SKIP_BITS(re, &s->gb, 1);
1847 UPDATE_CACHE(re, &s->gb);
1849 SKIP_BITS(re, &s->gb, 1);
1851 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1853 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//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 ESC1 level=%d\n", level);
1859 else if((i>62 && i<192) || i>192+63)
1860 fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1865 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1866 LAST_SKIP_BITS(re, &s->gb, 1);
1867 #ifdef ERROR_DETAILS
1869 fprintf(stderr, "illegal vlc code level=%d\n", level);
1870 else if((i>62 && i<192) || i>192+63)
1871 fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1877 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1878 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1879 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1882 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1887 block[scan_table[i]] = level;
1891 block[scan_table[i]] = level;
1893 CLOSE_READER(re, &s->gb);
1897 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1899 i = 63; /* XXX: not optimal */
1902 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1903 s->block_last_index[n] = i;
1908 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1912 if(s->msmpeg4_version<=2){
1914 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1916 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1921 }else{ //FIXME optimize use unified tables & index
1923 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1925 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1928 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1932 if (level == DC_MAX) {
1933 level = get_bits(&s->gb, 8);
1934 if (get_bits1(&s->gb))
1936 } else if (level != 0) {
1937 if (get_bits1(&s->gb))
1942 if(s->msmpeg4_version==1){
1944 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1947 /* update predictor */
1951 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1954 /* update predictor */
1956 *dc_val = level * s->y_dc_scale;
1958 *dc_val = level * s->c_dc_scale;
1965 static int msmpeg4_decode_motion(MpegEncContext * s,
1966 int *mx_ptr, int *my_ptr)
1971 mv = &mv_tables[s->mv_table_index];
1973 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1975 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1978 if (code == mv->n) {
1979 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1980 mx = get_bits(&s->gb, 6);
1981 my = get_bits(&s->gb, 6);
1983 mx = mv->table_mvx[code];
1984 my = mv->table_mvy[code];
1989 /* WARNING : they do not do exactly modulo encoding */
2004 /* cleanest way to support it
2005 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2006 * as allmost everything would be in the common file