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 file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
27 * MSMPEG4 backend for ffmpeg encoder and decoder.
32 #include "mpegvideo.h"
35 * You can also call this codec : MPEG4 with a twist !
38 * - (encoding) select best mv table (two choices)
39 * - (encoding) select best vlc/dc table
44 #define CBPY_VLC_BITS 6
45 #define INTER_INTRA_VLC_BITS 3
46 #define V1_INTRA_CBPC_VLC_BITS 6
47 #define V1_INTER_CBPC_VLC_BITS 6
48 #define V2_INTRA_CBPC_VLC_BITS 3
49 #define V2_MB_TYPE_VLC_BITS 7
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
53 #define MB_NON_INTRA_VLC_BITS 9
54 #define MB_INTRA_VLC_BITS 9
56 #define II_BITRATE 128*1024
57 #define MBAC_BITRATE 50*1024
59 #define DEFAULT_INTER_INDEX 3
61 static uint32_t v2_dc_lum_table[512][2];
62 static uint32_t v2_dc_chroma_table[512][2];
64 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
65 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
66 int n, int coded, const uint8_t *scantable);
67 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
68 static int msmpeg4_decode_motion(MpegEncContext * s,
69 int *mx_ptr, int *my_ptr);
70 static void init_h263_dc_for_msmpeg4(void);
71 static inline void msmpeg4_memsetw(short *tab, int val, int n);
72 #ifdef CONFIG_ENCODERS
73 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
74 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
75 #endif //CONFIG_ENCODERS
76 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
77 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
78 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
81 extern uint8_t wmv3_dc_scale_table[32];
88 #include "msmpeg4data.h"
90 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
91 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
92 #endif //CONFIG_ENCODERS
94 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
96 static void common_init(MpegEncContext * s)
100 switch(s->msmpeg4_version){
104 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
107 if(s->workaround_bugs){
108 s->y_dc_scale_table= old_ff_y_dc_scale_table;
109 s->c_dc_scale_table= old_ff_c_dc_scale_table;
111 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
112 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
117 s->y_dc_scale_table= wmv1_y_dc_scale_table;
118 s->c_dc_scale_table= wmv1_c_dc_scale_table;
120 #if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
122 s->y_dc_scale_table= wmv3_dc_scale_table;
123 s->c_dc_scale_table= wmv3_dc_scale_table;
130 if(s->msmpeg4_version>=4){
131 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
132 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
133 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
134 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
136 //Note the default tables are set in common_init in mpegvideo.c
141 init_h263_dc_for_msmpeg4();
145 #ifdef CONFIG_ENCODERS
147 /* build the table which associate a (x,y) motion vector to a vlc */
148 static void init_mv_table(MVTable *tab)
152 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
153 /* mark all entries as not used */
155 tab->table_mv_index[i] = tab->n;
157 for(i=0;i<tab->n;i++) {
158 x = tab->table_mvx[i];
159 y = tab->table_mvy[i];
160 tab->table_mv_index[(x << 6) | y] = i;
164 static void code012(PutBitContext *pb, int n)
170 put_bits(pb, 1, (n >= 2));
174 void ff_msmpeg4_encode_init(MpegEncContext *s)
176 static int init_done=0;
180 if(s->msmpeg4_version>=4){
186 /* init various encoding tables */
188 init_mv_table(&mv_tables[0]);
189 init_mv_table(&mv_tables[1]);
190 for(i=0;i<NB_RL_TABLES;i++)
191 init_rl(&rl_table[i], static_rl_table_store[i]);
193 for(i=0; i<NB_RL_TABLES; i++){
195 for(level=0; level<=MAX_LEVEL; level++){
197 for(run=0; run<=MAX_RUN; run++){
199 for(last=0; last<2; last++){
200 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
208 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
211 int run_diff= intra ? 0 : 1;
213 code = get_rl_index(rl, last, run, level);
214 size+= rl->table_vlc[code][1];
218 level1 = level - rl->max_level[last][run];
221 code = get_rl_index(rl, last, run, level1);
225 if (level > MAX_LEVEL)
227 run1 = run - rl->max_run[last][level] - run_diff;
230 code = get_rl_index(rl, last, run1, level);
237 size+= 1+1+ rl->table_vlc[code][1];
241 size+= 1+1+ rl->table_vlc[code][1];
249 static void find_best_tables(MpegEncContext * s)
252 int best =-1, best_size =9999999;
253 int chroma_best=-1, best_chroma_size=9999999;
264 for(level=0; level<=MAX_LEVEL; level++){
266 for(run=0; run<=MAX_RUN; run++){
268 const int last_size= size + chroma_size;
269 for(last=0; last<2; last++){
270 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
271 int intra_luma_count = s->ac_stats[1][0][level][run][last];
272 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
274 if(s->pict_type==I_TYPE){
275 size += intra_luma_count *rl_length[i ][level][run][last];
276 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
278 size+= intra_luma_count *rl_length[i ][level][run][last]
279 +intra_chroma_count*rl_length[i+3][level][run][last]
280 +inter_count *rl_length[i+3][level][run][last];
283 if(last_size == size+chroma_size) break;
290 if(chroma_size<best_chroma_size){
291 best_chroma_size= chroma_size;
296 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
297 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
299 if(s->pict_type==P_TYPE) chroma_best= best;
301 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
303 s->rl_table_index = best;
304 s->rl_chroma_table_index= chroma_best;
306 if(s->pict_type != s->last_non_b_pict_type){
307 s->rl_table_index= 2;
308 if(s->pict_type==I_TYPE)
309 s->rl_chroma_table_index= 1;
311 s->rl_chroma_table_index= 2;
316 /* write MSMPEG4 compatible frame header */
317 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
321 align_put_bits(&s->pb);
322 put_bits(&s->pb, 2, s->pict_type - 1);
324 put_bits(&s->pb, 5, s->qscale);
325 if(s->msmpeg4_version<=2){
326 s->rl_table_index = 2;
327 s->rl_chroma_table_index = 2;
330 s->dc_table_index = 1;
331 s->mv_table_index = 1; /* only if P frame */
332 s->use_skip_mb_code = 1; /* only if P frame */
333 s->per_mb_rl_table = 0;
334 if(s->msmpeg4_version==4)
335 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
336 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
338 if (s->pict_type == I_TYPE) {
339 s->slice_height= s->mb_height/1;
340 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
342 if(s->msmpeg4_version==4){
343 msmpeg4_encode_ext_header(s);
344 if(s->bit_rate>MBAC_BITRATE)
345 put_bits(&s->pb, 1, s->per_mb_rl_table);
348 if(s->msmpeg4_version>2){
349 if(!s->per_mb_rl_table){
350 code012(&s->pb, s->rl_chroma_table_index);
351 code012(&s->pb, s->rl_table_index);
354 put_bits(&s->pb, 1, s->dc_table_index);
357 put_bits(&s->pb, 1, s->use_skip_mb_code);
359 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
360 put_bits(&s->pb, 1, s->per_mb_rl_table);
362 if(s->msmpeg4_version>2){
363 if(!s->per_mb_rl_table)
364 code012(&s->pb, s->rl_table_index);
366 put_bits(&s->pb, 1, s->dc_table_index);
368 put_bits(&s->pb, 1, s->mv_table_index);
372 s->esc3_level_length= 0;
373 s->esc3_run_length= 0;
377 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
381 void msmpeg4_encode_ext_header(MpegEncContext * s)
383 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
385 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
387 if(s->msmpeg4_version>=3)
388 put_bits(&s->pb, 1, s->flipflop_rounding);
390 assert(s->flipflop_rounding==0);
393 #endif //CONFIG_ENCODERS
395 /* predict coded block */
396 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
398 int xy, wrap, pred, a, b, c;
400 xy = s->block_index[n];
406 a = s->coded_block[xy - 1 ];
407 b = s->coded_block[xy - 1 - wrap];
408 c = s->coded_block[xy - wrap];
417 *coded_block_ptr = &s->coded_block[xy];
422 #ifdef CONFIG_ENCODERS
424 static void msmpeg4_encode_motion(MpegEncContext * s,
430 /* modulo encoding */
431 /* WARNING : you cannot reach all the MVs even with the modulo
432 encoding. This is a somewhat strange compromise they took !!! */
445 if ((unsigned)mx >= 64 ||
447 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
449 mv = &mv_tables[s->mv_table_index];
451 code = mv->table_mv_index[(mx << 6) | my];
453 mv->table_mv_bits[code],
454 mv->table_mv_code[code]);
456 /* escape : code litterally */
457 put_bits(&s->pb, 6, mx);
458 put_bits(&s->pb, 6, my);
462 static inline void handle_slices(MpegEncContext *s){
464 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
465 if(s->msmpeg4_version < 4){
466 ff_mpeg4_clean_buffers(s);
468 s->first_slice_line = 1;
470 s->first_slice_line = 0;
475 void msmpeg4_encode_mb(MpegEncContext * s,
476 DCTELEM block[6][64],
477 int motion_x, int motion_y)
479 int cbp, coded_cbp, i;
481 uint8_t *coded_block;
488 for (i = 0; i < 6; i++) {
489 if (s->block_last_index[i] >= 0)
492 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
493 /* skip macroblock */
494 put_bits(&s->pb, 1, 1);
501 if (s->use_skip_mb_code)
502 put_bits(&s->pb, 1, 0); /* mb coded */
504 if(s->msmpeg4_version<=2){
506 v2_mb_type[cbp&3][1],
507 v2_mb_type[cbp&3][0]);
508 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
512 cbpy_tab[coded_cbp>>2][1],
513 cbpy_tab[coded_cbp>>2][0]);
515 s->misc_bits += get_bits_diff(s);
517 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
518 msmpeg4v2_encode_motion(s, motion_x - pred_x);
519 msmpeg4v2_encode_motion(s, motion_y - pred_y);
522 table_mb_non_intra[cbp + 64][1],
523 table_mb_non_intra[cbp + 64][0]);
525 s->misc_bits += get_bits_diff(s);
528 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
529 msmpeg4_encode_motion(s, motion_x - pred_x,
533 s->mv_bits += get_bits_diff(s);
535 for (i = 0; i < 6; i++) {
536 msmpeg4_encode_block(s, block[i], i);
538 s->p_tex_bits += get_bits_diff(s);
543 for (i = 0; i < 6; i++) {
545 val = (s->block_last_index[i] >= 1);
546 cbp |= val << (5 - i);
548 /* predict value for close blocks only for luma */
549 pred = coded_block_pred(s, i, &coded_block);
553 coded_cbp |= val << (5 - i);
557 printf("cbp=%x %x\n", cbp, coded_cbp);
560 if(s->msmpeg4_version<=2){
561 if (s->pict_type == I_TYPE) {
563 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
565 if (s->use_skip_mb_code)
566 put_bits(&s->pb, 1, 0); /* mb coded */
568 v2_mb_type[(cbp&3) + 4][1],
569 v2_mb_type[(cbp&3) + 4][0]);
571 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
574 cbpy_tab[cbp>>2][0]);
576 if (s->pict_type == I_TYPE) {
578 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
580 if (s->use_skip_mb_code)
581 put_bits(&s->pb, 1, 0); /* mb coded */
583 table_mb_non_intra[cbp][1],
584 table_mb_non_intra[cbp][0]);
586 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
587 if(s->inter_intra_pred){
589 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
592 s->misc_bits += get_bits_diff(s);
594 for (i = 0; i < 6; i++) {
595 msmpeg4_encode_block(s, block[i], i);
597 s->i_tex_bits += get_bits_diff(s);
602 #endif //CONFIG_ENCODERS
604 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
605 int32_t **dc_val_ptr)
615 *dc_val_ptr= &s->last_dc[i];
616 return s->last_dc[i];
619 static int get_dc(uint8_t *src, int stride, int scale)
626 sum+=src[x + y*stride];
629 return FASTDIV((sum + (scale>>1)), scale);
632 /* dir = 0: left, dir = 1: top prediction */
633 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
634 int16_t **dc_val_ptr, int *dir_ptr)
636 int a, b, c, wrap, pred, scale;
639 /* find prediction */
641 scale = s->y_dc_scale;
643 scale = s->c_dc_scale;
646 wrap = s->block_wrap[n];
647 dc_val= s->dc_val[0] + s->block_index[n];
653 b = dc_val[ - 1 - wrap];
656 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
660 /* XXX: the following solution consumes divisions, but it does not
661 necessitate to modify mpegvideo.c. The problem comes from the
662 fact they decided to store the quantized DC (which would lead
663 to problems if Q could vary !) */
664 #if (defined(ARCH_X86)) && !defined PIC
666 "movl %3, %%eax \n\t"
667 "shrl $1, %%eax \n\t"
668 "addl %%eax, %2 \n\t"
669 "addl %%eax, %1 \n\t"
670 "addl %0, %%eax \n\t"
672 "movl %%edx, %0 \n\t"
673 "movl %1, %%eax \n\t"
675 "movl %%edx, %1 \n\t"
676 "movl %2, %%eax \n\t"
678 "movl %%edx, %2 \n\t"
679 : "+b" (a), "+c" (b), "+D" (c)
680 : "g" (scale), "S" (ff_inverse[scale])
684 /* #elif defined (ARCH_ALPHA) */
685 /* Divisions are extremely costly on Alpha; optimize the most
686 common case. But they are costly everywhere...
689 a = (a + (8 >> 1)) / 8;
690 b = (b + (8 >> 1)) / 8;
691 c = (c + (8 >> 1)) / 8;
693 a = FASTDIV((a + (scale >> 1)), scale);
694 b = FASTDIV((b + (scale >> 1)), scale);
695 c = FASTDIV((c + (scale >> 1)), scale);
698 /* XXX: WARNING: they did not choose the same test as MPEG4. This
699 is very important ! */
700 if(s->msmpeg4_version>3){
701 if(s->inter_intra_pred){
712 if (abs(a - b) < abs(b - c)) {
722 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
725 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
727 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
728 else a= get_dc(dest-8, wrap, scale*8);
729 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
730 else c= get_dc(dest-8*wrap, wrap, scale*8);
732 if (s->h263_aic_dir==0) {
735 }else if (s->h263_aic_dir==1) {
743 }else if (s->h263_aic_dir==2) {
757 if (abs(a - b) < abs(b - c)) {
766 if (abs(a - b) <= abs(b - c)) {
775 /* update predictor */
776 *dc_val_ptr = &dc_val[0];
782 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
787 if(s->msmpeg4_version==1){
789 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
791 /* update predictor */
795 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
797 /* update predictor */
799 *dc_val = level * s->y_dc_scale;
801 *dc_val = level * s->c_dc_scale;
805 /* do the prediction */
808 if(s->msmpeg4_version<=2){
811 v2_dc_lum_table[level+256][1],
812 v2_dc_lum_table[level+256][0]);
815 v2_dc_chroma_table[level+256][1],
816 v2_dc_chroma_table[level+256][0]);
828 if (s->dc_table_index == 0) {
830 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
832 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
836 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
838 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
843 put_bits(&s->pb, 8, level);
846 put_bits(&s->pb, 1, sign);
851 /* Encoding of a block. Very similar to MPEG4 except for a different
852 escape coding (same as H263) and more vlc tables.
854 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
856 int level, run, last, i, j, last_index;
857 int last_non_zero, sign, slevel;
858 int code, run_diff, dc_pred_dir;
860 const uint8_t *scantable;
863 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
866 rl = &rl_table[s->rl_table_index];
868 rl = &rl_table[3 + s->rl_chroma_table_index];
871 scantable= s->intra_scantable.permutated;
874 rl = &rl_table[3 + s->rl_table_index];
875 if(s->msmpeg4_version<=2)
879 scantable= s->inter_scantable.permutated;
882 /* recalculate block_last_index for M$ wmv1 */
883 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
884 for(last_index=63; last_index>=0; last_index--){
885 if(block[scantable[last_index]]) break;
887 s->block_last_index[n]= last_index;
889 last_index = s->block_last_index[n];
891 last_non_zero = i - 1;
892 for (; i <= last_index; i++) {
896 run = i - last_non_zero - 1;
897 last = (i == last_index);
905 if(level<=MAX_LEVEL && run<=MAX_RUN){
906 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
910 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
912 code = get_rl_index(rl, last, run, level);
913 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
917 level1 = level - rl->max_level[last][run];
920 code = get_rl_index(rl, last, run, level1);
923 put_bits(&s->pb, 1, 0);
924 if (level > MAX_LEVEL)
926 run1 = run - rl->max_run[last][level] - run_diff;
929 code = get_rl_index(rl, last, run1, level);
933 put_bits(&s->pb, 1, 0);
934 put_bits(&s->pb, 1, last);
935 if(s->msmpeg4_version>=4){
936 if(s->esc3_level_length==0){
937 s->esc3_level_length=8;
938 s->esc3_run_length= 6;
940 put_bits(&s->pb, 6, 3);
942 put_bits(&s->pb, 8, 3);
944 put_bits(&s->pb, s->esc3_run_length, run);
945 put_bits(&s->pb, 1, sign);
946 put_bits(&s->pb, s->esc3_level_length, level);
948 put_bits(&s->pb, 6, run);
949 put_bits(&s->pb, 8, slevel & 0xff);
953 put_bits(&s->pb, 1, 1);
954 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
955 put_bits(&s->pb, 1, sign);
959 put_bits(&s->pb, 1, 1);
960 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
961 put_bits(&s->pb, 1, sign);
964 put_bits(&s->pb, 1, sign);
971 /****************************************/
974 static VLC mb_non_intra_vlc[4];
975 VLC ff_msmp4_mb_i_vlc;
976 VLC ff_msmp4_dc_luma_vlc[2];
977 VLC ff_msmp4_dc_chroma_vlc[2];
978 static VLC v2_dc_lum_vlc;
979 static VLC v2_dc_chroma_vlc;
981 static VLC v2_intra_cbpc_vlc;
982 static VLC v2_mb_type_vlc;
983 static VLC v2_mv_vlc;
984 static VLC v1_intra_cbpc_vlc;
985 static VLC v1_inter_cbpc_vlc;
986 static VLC inter_intra_vlc;
988 /* this table is practically identical to the one from h263 except that its inverted */
989 static void init_h263_dc_for_msmpeg4(void)
991 int level, uni_code, uni_len;
993 for(level=-256; level<256; level++){
995 /* find number of bits */
1004 l= (-level) ^ ((1 << size) - 1);
1008 /* luminance h263 */
1009 uni_code= DCtab_lum[size][0];
1010 uni_len = DCtab_lum[size][1];
1011 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1014 uni_code<<=size; uni_code|=l;
1017 uni_code<<=1; uni_code|=1;
1021 v2_dc_lum_table[level+256][0]= uni_code;
1022 v2_dc_lum_table[level+256][1]= uni_len;
1024 /* chrominance h263 */
1025 uni_code= DCtab_chrom[size][0];
1026 uni_len = DCtab_chrom[size][1];
1027 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1030 uni_code<<=size; uni_code|=l;
1033 uni_code<<=1; uni_code|=1;
1037 v2_dc_chroma_table[level+256][0]= uni_code;
1038 v2_dc_chroma_table[level+256][1]= uni_len;
1043 /* init all vlc decoding tables */
1044 int ff_msmpeg4_decode_init(MpegEncContext *s)
1046 static int done = 0;
1055 for(i=0;i<NB_RL_TABLES;i++) {
1056 init_rl(&rl_table[i], static_rl_table_store[i]);
1057 init_vlc_rl(&rl_table[i], 1);
1061 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1062 mv->table_mv_bits, 1, 1,
1063 mv->table_mv_code, 2, 2, 1);
1066 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1067 &ff_table0_dc_lum[0][1], 8, 4,
1068 &ff_table0_dc_lum[0][0], 8, 4, 1);
1069 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1070 &ff_table0_dc_chroma[0][1], 8, 4,
1071 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1072 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1073 &ff_table1_dc_lum[0][1], 8, 4,
1074 &ff_table1_dc_lum[0][0], 8, 4, 1);
1075 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1076 &ff_table1_dc_chroma[0][1], 8, 4,
1077 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1079 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1080 &v2_dc_lum_table[0][1], 8, 4,
1081 &v2_dc_lum_table[0][0], 8, 4, 1);
1082 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1083 &v2_dc_chroma_table[0][1], 8, 4,
1084 &v2_dc_chroma_table[0][0], 8, 4, 1);
1086 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1087 &cbpy_tab[0][1], 2, 1,
1088 &cbpy_tab[0][0], 2, 1, 1);
1089 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1090 &v2_intra_cbpc[0][1], 2, 1,
1091 &v2_intra_cbpc[0][0], 2, 1, 1);
1092 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1093 &v2_mb_type[0][1], 2, 1,
1094 &v2_mb_type[0][0], 2, 1, 1);
1095 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1097 &mvtab[0][0], 2, 1, 1);
1100 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1101 &wmv2_inter_table[i][0][1], 8, 4,
1102 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1105 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1106 &ff_msmp4_mb_i_table[0][1], 4, 2,
1107 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1109 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1110 intra_MCBPC_bits, 1, 1,
1111 intra_MCBPC_code, 1, 1, 1);
1112 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1113 inter_MCBPC_bits, 1, 1,
1114 inter_MCBPC_code, 1, 1, 1);
1116 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1117 &table_inter_intra[0][1], 2, 1,
1118 &table_inter_intra[0][0], 2, 1, 1);
1121 switch(s->msmpeg4_version){
1124 s->decode_mb= msmpeg4v12_decode_mb;
1128 s->decode_mb= msmpeg4v34_decode_mb;
1131 s->decode_mb= wmv2_decode_mb;
1133 //FIXME + TODO VC1 decode mb
1137 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1142 int msmpeg4_decode_picture_header(MpegEncContext * s)
1149 for(i=0; i<s->gb.size_in_bits; i++)
1150 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1151 // get_bits1(&s->gb);
1152 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1157 if(s->msmpeg4_version==1){
1158 int start_code, num;
1159 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1160 if(start_code!=0x00000100){
1161 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1165 num= get_bits(&s->gb, 5); // frame number */
1168 s->pict_type = get_bits(&s->gb, 2) + 1;
1169 if (s->pict_type != I_TYPE &&
1170 s->pict_type != P_TYPE){
1171 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1177 if(s->pict_type == I_TYPE) had_i=1;
1178 if(!had_i) return -1;
1181 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1183 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1187 if (s->pict_type == I_TYPE) {
1188 code = get_bits(&s->gb, 5);
1189 if(s->msmpeg4_version==1){
1190 if(code==0 || code>s->mb_height){
1191 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1195 s->slice_height = code;
1197 /* 0x17: one slice, 0x18: two slices, ... */
1199 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1203 s->slice_height = s->mb_height / (code - 0x16);
1206 switch(s->msmpeg4_version){
1209 s->rl_chroma_table_index = 2;
1210 s->rl_table_index = 2;
1212 s->dc_table_index = 0; //not used
1215 s->rl_chroma_table_index = decode012(&s->gb);
1216 s->rl_table_index = decode012(&s->gb);
1218 s->dc_table_index = get_bits1(&s->gb);
1221 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1223 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1224 else s->per_mb_rl_table= 0;
1226 if(!s->per_mb_rl_table){
1227 s->rl_chroma_table_index = decode012(&s->gb);
1228 s->rl_table_index = decode012(&s->gb);
1231 s->dc_table_index = get_bits1(&s->gb);
1232 s->inter_intra_pred= 0;
1236 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1237 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1239 s->rl_chroma_table_index,
1245 switch(s->msmpeg4_version){
1248 if(s->msmpeg4_version==1)
1249 s->use_skip_mb_code = 1;
1251 s->use_skip_mb_code = get_bits1(&s->gb);
1252 s->rl_table_index = 2;
1253 s->rl_chroma_table_index = s->rl_table_index;
1254 s->dc_table_index = 0; //not used
1255 s->mv_table_index = 0;
1258 s->use_skip_mb_code = get_bits1(&s->gb);
1259 s->rl_table_index = decode012(&s->gb);
1260 s->rl_chroma_table_index = s->rl_table_index;
1262 s->dc_table_index = get_bits1(&s->gb);
1264 s->mv_table_index = get_bits1(&s->gb);
1267 s->use_skip_mb_code = get_bits1(&s->gb);
1269 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1270 else s->per_mb_rl_table= 0;
1272 if(!s->per_mb_rl_table){
1273 s->rl_table_index = decode012(&s->gb);
1274 s->rl_chroma_table_index = s->rl_table_index;
1277 s->dc_table_index = get_bits1(&s->gb);
1279 s->mv_table_index = get_bits1(&s->gb);
1280 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1284 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1285 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1286 s->use_skip_mb_code,
1288 s->rl_chroma_table_index,
1294 if(s->flipflop_rounding){
1295 s->no_rounding ^= 1;
1300 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1302 s->esc3_level_length= 0;
1303 s->esc3_run_length= 0;
1306 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1311 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1313 int left= buf_size*8 - get_bits_count(&s->gb);
1314 int length= s->msmpeg4_version>=3 ? 17 : 16;
1315 /* the alt_bitstream reader could read over the end so we need to check it */
1316 if(left>=length && left<length+8)
1320 fps= get_bits(&s->gb, 5);
1321 s->bit_rate= get_bits(&s->gb, 11)*1024;
1322 if(s->msmpeg4_version>=3)
1323 s->flipflop_rounding= get_bits1(&s->gb);
1325 s->flipflop_rounding= 0;
1327 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1329 else if(left<length+8)
1331 s->flipflop_rounding= 0;
1332 if(s->msmpeg4_version != 2)
1333 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1337 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1343 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1350 #ifdef CONFIG_ENCODERS
1351 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1353 int range, bit_size, sign, code, bits;
1358 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1360 bit_size = s->f_code - 1;
1361 range = 1 << bit_size;
1374 code = (val >> bit_size) + 1;
1375 bits = val & (range - 1);
1377 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1379 put_bits(&s->pb, bit_size, bits);
1385 /* this is identical to h263 except that its range is multiplied by 2 */
1386 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1388 int code, val, sign, shift;
1390 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1391 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1397 sign = get_bits1(&s->gb);
1401 val = (val - 1) << shift;
1402 val |= get_bits(&s->gb, shift);
1417 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1421 if (s->pict_type == P_TYPE) {
1422 if (s->use_skip_mb_code) {
1423 if (get_bits1(&s->gb)) {
1427 s->block_last_index[i] = -1;
1428 s->mv_dir = MV_DIR_FORWARD;
1429 s->mv_type = MV_TYPE_16X16;
1437 if(s->msmpeg4_version==2)
1438 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1440 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1441 if(code<0 || code>7){
1442 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1446 s->mb_intra = code >>2;
1451 if(s->msmpeg4_version==2)
1452 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1454 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1456 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1464 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1466 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1471 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1473 h263_pred_motion(s, 0, 0, &mx, &my);
1474 mx= msmpeg4v2_decode_motion(s, mx, 1);
1475 my= msmpeg4v2_decode_motion(s, my, 1);
1477 s->mv_dir = MV_DIR_FORWARD;
1478 s->mv_type = MV_TYPE_16X16;
1479 s->mv[0][0][0] = mx;
1480 s->mv[0][0][1] = my;
1482 if(s->msmpeg4_version==2){
1483 s->ac_pred = get_bits1(&s->gb);
1484 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1487 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1488 if(s->pict_type==P_TYPE) cbp^=0x3C;
1492 s->dsp.clear_blocks(s->block[0]);
1493 for (i = 0; i < 6; i++) {
1494 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1496 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1503 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1507 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1509 if (s->pict_type == P_TYPE) {
1510 if (s->use_skip_mb_code) {
1511 if (get_bits1(&s->gb)) {
1515 s->block_last_index[i] = -1;
1516 s->mv_dir = MV_DIR_FORWARD;
1517 s->mv_type = MV_TYPE_16X16;
1521 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1527 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1530 //s->mb_intra = (code & 0x40) ? 0 : 1;
1531 s->mb_intra = (~code & 0x40) >> 6;
1536 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1539 /* predict coded block pattern */
1542 int val = ((code >> (5 - i)) & 1);
1544 int pred = coded_block_pred(s, i, &coded_val);
1548 cbp |= val << (5 - i);
1554 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1555 if(s->per_mb_rl_table && cbp){
1556 s->rl_table_index = decode012(&s->gb);
1557 s->rl_chroma_table_index = s->rl_table_index;
1559 h263_pred_motion(s, 0, 0, &mx, &my);
1560 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1562 s->mv_dir = MV_DIR_FORWARD;
1563 s->mv_type = MV_TYPE_16X16;
1564 s->mv[0][0][0] = mx;
1565 s->mv[0][0][1] = my;
1566 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1568 //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));
1569 s->ac_pred = get_bits1(&s->gb);
1570 *mb_type_ptr = MB_TYPE_INTRA;
1571 if(s->inter_intra_pred){
1572 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1573 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1575 if(s->per_mb_rl_table && cbp){
1576 s->rl_table_index = decode012(&s->gb);
1577 s->rl_chroma_table_index = s->rl_table_index;
1581 s->dsp.clear_blocks(s->block[0]);
1582 for (i = 0; i < 6; i++) {
1583 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1585 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1592 //#define ERROR_DETAILS
1593 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1594 int n, int coded, const uint8_t *scan_table)
1596 int level, i, last, run, run_diff;
1599 RL_VLC_ELEM *rl_vlc;
1607 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1610 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1611 if(s->inter_intra_pred) level=0;
1615 rl = &rl_table[s->rl_table_index];
1616 if(level > 256*s->y_dc_scale){
1617 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1618 if(!s->inter_intra_pred) return -1;
1621 rl = &rl_table[3 + s->rl_chroma_table_index];
1622 if(level > 256*s->c_dc_scale){
1623 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1624 if(!s->inter_intra_pred) return -1;
1635 if (dc_pred_dir == 0)
1636 scan_table = s->intra_v_scantable.permutated; /* left */
1638 scan_table = s->intra_h_scantable.permutated; /* top */
1640 scan_table = s->intra_scantable.permutated;
1642 rl_vlc= rl->rl_vlc[0];
1644 qmul = s->qscale << 1;
1645 qadd = (s->qscale - 1) | 1;
1647 rl = &rl_table[3 + s->rl_table_index];
1649 if(s->msmpeg4_version==2)
1655 s->block_last_index[n] = i;
1659 scan_table = s->inter_scantable.permutated;
1660 rl_vlc= rl->rl_vlc[s->qscale];
1663 OPEN_READER(re, &s->gb);
1665 UPDATE_CACHE(re, &s->gb);
1666 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1669 cache= GET_CACHE(re, &s->gb);
1671 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1672 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1674 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1675 UPDATE_CACHE(re, &s->gb);
1676 if(s->msmpeg4_version<=3){
1677 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1678 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1679 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1680 SKIP_COUNTER(re, &s->gb, 1+6+8);
1683 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1684 if(!s->esc3_level_length){
1686 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1688 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1690 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");
1691 SKIP_BITS(re, &s->gb, 1);
1696 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1698 SKIP_BITS(re, &s->gb, 1);
1700 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1703 s->esc3_level_length= ll;
1704 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1705 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1706 UPDATE_CACHE(re, &s->gb);
1708 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1709 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1711 sign= SHOW_UBITS(re, &s->gb, 1);
1712 SKIP_BITS(re, &s->gb, 1);
1714 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1715 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1716 if(sign) level= -level;
1718 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1719 #if 0 // waste of time / this will detect very few errors
1721 const int abs_level= FFABS(level);
1722 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1723 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1724 if(abs_level <= rl->max_level[last][run]){
1725 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1726 return DECODING_AC_LOST;
1728 if(abs_level <= rl->max_level[last][run]*2){
1729 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1730 return DECODING_AC_LOST;
1732 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1733 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1734 return DECODING_AC_LOST;
1739 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1740 if (level>0) level= level * qmul + qadd;
1741 else level= level * qmul - qadd;
1742 #if 0 // waste of time too :(
1743 if(level>2048 || level<-2048){
1744 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1745 return DECODING_AC_LOST;
1750 #ifdef ERROR_DETAILS
1752 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1753 else if((i>62 && i<192) || i>192+63)
1754 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1758 #if MIN_CACHE_BITS < 23
1759 LAST_SKIP_BITS(re, &s->gb, 2);
1760 UPDATE_CACHE(re, &s->gb);
1762 SKIP_BITS(re, &s->gb, 2);
1764 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1765 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1766 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1767 LAST_SKIP_BITS(re, &s->gb, 1);
1768 #ifdef ERROR_DETAILS
1770 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1771 else if((i>62 && i<192) || i>192+63)
1772 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1777 #if MIN_CACHE_BITS < 22
1778 LAST_SKIP_BITS(re, &s->gb, 1);
1779 UPDATE_CACHE(re, &s->gb);
1781 SKIP_BITS(re, &s->gb, 1);
1783 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1785 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1786 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1787 LAST_SKIP_BITS(re, &s->gb, 1);
1788 #ifdef ERROR_DETAILS
1790 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1791 else if((i>62 && i<192) || i>192+63)
1792 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1797 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1798 LAST_SKIP_BITS(re, &s->gb, 1);
1799 #ifdef ERROR_DETAILS
1801 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1802 else if((i>62 && i<192) || i>192+63)
1803 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1809 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1810 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1811 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1814 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1819 block[scan_table[i]] = level;
1823 block[scan_table[i]] = level;
1825 CLOSE_READER(re, &s->gb);
1829 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1831 i = 63; /* XXX: not optimal */
1834 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1835 s->block_last_index[n] = i;
1840 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1844 if(s->msmpeg4_version<=2){
1846 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1848 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1853 }else{ //FIXME optimize use unified tables & index
1855 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1857 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1860 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1864 if (level == DC_MAX) {
1865 level = get_bits(&s->gb, 8);
1866 if (get_bits1(&s->gb))
1868 } else if (level != 0) {
1869 if (get_bits1(&s->gb))
1874 if(s->msmpeg4_version==1){
1876 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1879 /* update predictor */
1883 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1886 /* update predictor */
1888 *dc_val = level * s->y_dc_scale;
1890 *dc_val = level * s->c_dc_scale;
1897 static int msmpeg4_decode_motion(MpegEncContext * s,
1898 int *mx_ptr, int *my_ptr)
1903 mv = &mv_tables[s->mv_table_index];
1905 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1907 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1910 if (code == mv->n) {
1911 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1912 mx = get_bits(&s->gb, 6);
1913 my = get_bits(&s->gb, 6);
1915 mx = mv->table_mvx[code];
1916 my = mv->table_mvy[code];
1921 /* WARNING : they do not do exactly modulo encoding */
1936 /* cleanest way to support it
1937 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1938 * as allmost everything would be in the common file