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 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * MSMPEG4 backend for ffmpeg encoder and decoder.
32 #include "mpegvideo.h"
36 * You can also call this codec : MPEG4 with a twist !
39 * - (encoding) select best mv table (two choices)
40 * - (encoding) select best vlc/dc table
45 #define CBPY_VLC_BITS 6
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
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 int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
63 static void init_h263_dc_for_msmpeg4(void);
64 static inline void msmpeg4_memsetw(short *tab, int val, int n);
65 #ifdef CONFIG_ENCODERS
66 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
67 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
68 #endif //CONFIG_ENCODERS
69 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
70 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
73 extern const uint8_t wmv3_dc_scale_table[32];
80 #include "msmpeg4data.h"
82 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if it is not references
83 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
84 #endif //CONFIG_ENCODERS
86 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
88 static void common_init(MpegEncContext * s)
90 static int initialized=0;
92 switch(s->msmpeg4_version){
96 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
99 if(s->workaround_bugs){
100 s->y_dc_scale_table= old_ff_y_dc_scale_table;
101 s->c_dc_scale_table= old_ff_c_dc_scale_table;
103 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
104 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
109 s->y_dc_scale_table= wmv1_y_dc_scale_table;
110 s->c_dc_scale_table= wmv1_c_dc_scale_table;
112 #if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
114 s->y_dc_scale_table= wmv3_dc_scale_table;
115 s->c_dc_scale_table= wmv3_dc_scale_table;
122 if(s->msmpeg4_version>=4){
123 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
124 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
125 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
126 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
128 //Note the default tables are set in common_init in mpegvideo.c
133 init_h263_dc_for_msmpeg4();
137 #ifdef CONFIG_ENCODERS
139 /* build the table which associate a (x,y) motion vector to a vlc */
140 static void init_mv_table(MVTable *tab)
144 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
145 /* mark all entries as not used */
147 tab->table_mv_index[i] = tab->n;
149 for(i=0;i<tab->n;i++) {
150 x = tab->table_mvx[i];
151 y = tab->table_mvy[i];
152 tab->table_mv_index[(x << 6) | y] = i;
156 void ff_msmpeg4_code012(PutBitContext *pb, int n)
162 put_bits(pb, 1, (n >= 2));
166 void ff_msmpeg4_encode_init(MpegEncContext *s)
168 static int init_done=0;
172 if(s->msmpeg4_version>=4){
178 /* init various encoding tables */
180 init_mv_table(&mv_tables[0]);
181 init_mv_table(&mv_tables[1]);
182 for(i=0;i<NB_RL_TABLES;i++)
183 init_rl(&rl_table[i], static_rl_table_store[i]);
185 for(i=0; i<NB_RL_TABLES; i++){
187 for(level=0; level<=MAX_LEVEL; level++){
189 for(run=0; run<=MAX_RUN; run++){
191 for(last=0; last<2; last++){
192 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
200 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
203 int run_diff= intra ? 0 : 1;
205 code = get_rl_index(rl, last, run, level);
206 size+= rl->table_vlc[code][1];
210 level1 = level - rl->max_level[last][run];
213 code = get_rl_index(rl, last, run, level1);
217 if (level > MAX_LEVEL)
219 run1 = run - rl->max_run[last][level] - run_diff;
222 code = get_rl_index(rl, last, run1, level);
229 size+= 1+1+ rl->table_vlc[code][1];
233 size+= 1+1+ rl->table_vlc[code][1];
241 void ff_find_best_tables(MpegEncContext * s)
244 int best =-1, best_size =9999999;
245 int chroma_best=-1, best_chroma_size=9999999;
256 for(level=0; level<=MAX_LEVEL; level++){
258 for(run=0; run<=MAX_RUN; run++){
260 const int last_size= size + chroma_size;
261 for(last=0; last<2; last++){
262 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
263 int intra_luma_count = s->ac_stats[1][0][level][run][last];
264 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
266 if(s->pict_type==FF_I_TYPE){
267 size += intra_luma_count *rl_length[i ][level][run][last];
268 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
270 size+= intra_luma_count *rl_length[i ][level][run][last]
271 +intra_chroma_count*rl_length[i+3][level][run][last]
272 +inter_count *rl_length[i+3][level][run][last];
275 if(last_size == size+chroma_size) break;
282 if(chroma_size<best_chroma_size){
283 best_chroma_size= chroma_size;
288 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
289 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
291 if(s->pict_type==FF_P_TYPE) chroma_best= best;
293 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
295 s->rl_table_index = best;
296 s->rl_chroma_table_index= chroma_best;
298 if(s->pict_type != s->last_non_b_pict_type){
299 s->rl_table_index= 2;
300 if(s->pict_type==FF_I_TYPE)
301 s->rl_chroma_table_index= 1;
303 s->rl_chroma_table_index= 2;
308 /* write MSMPEG4 compatible frame header */
309 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
311 ff_find_best_tables(s);
313 align_put_bits(&s->pb);
314 put_bits(&s->pb, 2, s->pict_type - 1);
316 put_bits(&s->pb, 5, s->qscale);
317 if(s->msmpeg4_version<=2){
318 s->rl_table_index = 2;
319 s->rl_chroma_table_index = 2;
322 s->dc_table_index = 1;
323 s->mv_table_index = 1; /* only if P frame */
324 s->use_skip_mb_code = 1; /* only if P frame */
325 s->per_mb_rl_table = 0;
326 if(s->msmpeg4_version==4)
327 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
328 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
330 if (s->pict_type == FF_I_TYPE) {
331 s->slice_height= s->mb_height/1;
332 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
334 if(s->msmpeg4_version==4){
335 msmpeg4_encode_ext_header(s);
336 if(s->bit_rate>MBAC_BITRATE)
337 put_bits(&s->pb, 1, s->per_mb_rl_table);
340 if(s->msmpeg4_version>2){
341 if(!s->per_mb_rl_table){
342 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
343 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
346 put_bits(&s->pb, 1, s->dc_table_index);
349 put_bits(&s->pb, 1, s->use_skip_mb_code);
351 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
352 put_bits(&s->pb, 1, s->per_mb_rl_table);
354 if(s->msmpeg4_version>2){
355 if(!s->per_mb_rl_table)
356 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
358 put_bits(&s->pb, 1, s->dc_table_index);
360 put_bits(&s->pb, 1, s->mv_table_index);
364 s->esc3_level_length= 0;
365 s->esc3_run_length= 0;
369 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
373 void msmpeg4_encode_ext_header(MpegEncContext * s)
375 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
377 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
379 if(s->msmpeg4_version>=3)
380 put_bits(&s->pb, 1, s->flipflop_rounding);
382 assert(s->flipflop_rounding==0);
385 #endif //CONFIG_ENCODERS
387 /* predict coded block */
388 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
390 int xy, wrap, pred, a, b, c;
392 xy = s->block_index[n];
398 a = s->coded_block[xy - 1 ];
399 b = s->coded_block[xy - 1 - wrap];
400 c = s->coded_block[xy - wrap];
409 *coded_block_ptr = &s->coded_block[xy];
414 #ifdef CONFIG_ENCODERS
416 void ff_msmpeg4_encode_motion(MpegEncContext * s,
422 /* modulo encoding */
423 /* WARNING : you cannot reach all the MVs even with the modulo
424 encoding. This is a somewhat strange compromise they took !!! */
437 if ((unsigned)mx >= 64 ||
439 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
441 mv = &mv_tables[s->mv_table_index];
443 code = mv->table_mv_index[(mx << 6) | my];
445 mv->table_mv_bits[code],
446 mv->table_mv_code[code]);
448 /* escape : code literally */
449 put_bits(&s->pb, 6, mx);
450 put_bits(&s->pb, 6, my);
454 void ff_msmpeg4_handle_slices(MpegEncContext *s){
456 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
457 if(s->msmpeg4_version < 4){
458 ff_mpeg4_clean_buffers(s);
460 s->first_slice_line = 1;
462 s->first_slice_line = 0;
467 void msmpeg4_encode_mb(MpegEncContext * s,
468 DCTELEM block[6][64],
469 int motion_x, int motion_y)
471 int cbp, coded_cbp, i;
473 uint8_t *coded_block;
475 ff_msmpeg4_handle_slices(s);
480 for (i = 0; i < 6; i++) {
481 if (s->block_last_index[i] >= 0)
484 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
485 /* skip macroblock */
486 put_bits(&s->pb, 1, 1);
493 if (s->use_skip_mb_code)
494 put_bits(&s->pb, 1, 0); /* mb coded */
496 if(s->msmpeg4_version<=2){
498 v2_mb_type[cbp&3][1],
499 v2_mb_type[cbp&3][0]);
500 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
504 cbpy_tab[coded_cbp>>2][1],
505 cbpy_tab[coded_cbp>>2][0]);
507 s->misc_bits += get_bits_diff(s);
509 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
510 msmpeg4v2_encode_motion(s, motion_x - pred_x);
511 msmpeg4v2_encode_motion(s, motion_y - pred_y);
514 table_mb_non_intra[cbp + 64][1],
515 table_mb_non_intra[cbp + 64][0]);
517 s->misc_bits += get_bits_diff(s);
520 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
521 ff_msmpeg4_encode_motion(s, motion_x - pred_x,
525 s->mv_bits += get_bits_diff(s);
527 for (i = 0; i < 6; i++) {
528 ff_msmpeg4_encode_block(s, block[i], i);
530 s->p_tex_bits += get_bits_diff(s);
535 for (i = 0; i < 6; i++) {
537 val = (s->block_last_index[i] >= 1);
538 cbp |= val << (5 - i);
540 /* predict value for close blocks only for luma */
541 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
545 coded_cbp |= val << (5 - i);
549 printf("cbp=%x %x\n", cbp, coded_cbp);
552 if(s->msmpeg4_version<=2){
553 if (s->pict_type == FF_I_TYPE) {
555 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
557 if (s->use_skip_mb_code)
558 put_bits(&s->pb, 1, 0); /* mb coded */
560 v2_mb_type[(cbp&3) + 4][1],
561 v2_mb_type[(cbp&3) + 4][0]);
563 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
566 cbpy_tab[cbp>>2][0]);
568 if (s->pict_type == FF_I_TYPE) {
570 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
572 if (s->use_skip_mb_code)
573 put_bits(&s->pb, 1, 0); /* mb coded */
575 table_mb_non_intra[cbp][1],
576 table_mb_non_intra[cbp][0]);
578 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
579 if(s->inter_intra_pred){
581 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
584 s->misc_bits += get_bits_diff(s);
586 for (i = 0; i < 6; i++) {
587 ff_msmpeg4_encode_block(s, block[i], i);
589 s->i_tex_bits += get_bits_diff(s);
594 #endif //CONFIG_ENCODERS
596 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
597 int32_t **dc_val_ptr)
607 *dc_val_ptr= &s->last_dc[i];
608 return s->last_dc[i];
611 static int get_dc(uint8_t *src, int stride, int scale)
618 sum+=src[x + y*stride];
621 return FASTDIV((sum + (scale>>1)), scale);
624 /* dir = 0: left, dir = 1: top prediction */
625 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
626 int16_t **dc_val_ptr, int *dir_ptr)
628 int a, b, c, wrap, pred, scale;
631 /* find prediction */
633 scale = s->y_dc_scale;
635 scale = s->c_dc_scale;
638 wrap = s->block_wrap[n];
639 dc_val= s->dc_val[0] + s->block_index[n];
645 b = dc_val[ - 1 - wrap];
648 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
652 /* XXX: the following solution consumes divisions, but it does not
653 necessitate to modify mpegvideo.c. The problem comes from the
654 fact they decided to store the quantized DC (which would lead
655 to problems if Q could vary !) */
656 #if (defined(ARCH_X86)) && !defined PIC
658 "movl %3, %%eax \n\t"
659 "shrl $1, %%eax \n\t"
660 "addl %%eax, %2 \n\t"
661 "addl %%eax, %1 \n\t"
662 "addl %0, %%eax \n\t"
664 "movl %%edx, %0 \n\t"
665 "movl %1, %%eax \n\t"
667 "movl %%edx, %1 \n\t"
668 "movl %2, %%eax \n\t"
670 "movl %%edx, %2 \n\t"
671 : "+b" (a), "+c" (b), "+D" (c)
672 : "g" (scale), "S" (ff_inverse[scale])
676 /* #elif defined (ARCH_ALPHA) */
677 /* Divisions are extremely costly on Alpha; optimize the most
678 common case. But they are costly everywhere...
681 a = (a + (8 >> 1)) / 8;
682 b = (b + (8 >> 1)) / 8;
683 c = (c + (8 >> 1)) / 8;
685 a = FASTDIV((a + (scale >> 1)), scale);
686 b = FASTDIV((b + (scale >> 1)), scale);
687 c = FASTDIV((c + (scale >> 1)), scale);
690 /* XXX: WARNING: they did not choose the same test as MPEG4. This
691 is very important ! */
692 if(s->msmpeg4_version>3){
693 if(s->inter_intra_pred){
704 if (abs(a - b) < abs(b - c)) {
714 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
717 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
719 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
720 else a= get_dc(dest-8, wrap, scale*8);
721 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
722 else c= get_dc(dest-8*wrap, wrap, scale*8);
724 if (s->h263_aic_dir==0) {
727 }else if (s->h263_aic_dir==1) {
735 }else if (s->h263_aic_dir==2) {
749 if (abs(a - b) < abs(b - c)) {
758 if (abs(a - b) <= abs(b - c)) {
767 /* update predictor */
768 *dc_val_ptr = &dc_val[0];
774 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
780 if(s->msmpeg4_version==1){
782 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
784 /* update predictor */
788 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
790 /* update predictor */
792 *dc_val = level * s->y_dc_scale;
794 *dc_val = level * s->c_dc_scale;
798 /* do the prediction */
801 if(s->msmpeg4_version<=2){
804 v2_dc_lum_table[level+256][1],
805 v2_dc_lum_table[level+256][0]);
808 v2_dc_chroma_table[level+256][1],
809 v2_dc_chroma_table[level+256][0]);
820 else if( s->msmpeg4_version>=6 ) {
821 if( s->qscale == 1 ) {
822 extquant = (level + 3) & 0x3;
823 code = ((level+3)>>2);
824 } else if( s->qscale == 2 ) {
825 extquant = (level + 1) & 0x1;
826 code = ((level+1)>>1);
830 if (s->dc_table_index == 0) {
832 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
834 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
838 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
840 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
844 if(s->msmpeg4_version>=6 && s->qscale<=2)
845 extrabits = 3 - s->qscale;
848 put_bits(&s->pb, 8 + extrabits, level);
849 else if(extrabits > 0)//== VC1 && s->qscale<=2
850 put_bits(&s->pb, extrabits, extquant);
853 put_bits(&s->pb, 1, sign);
858 /* Encoding of a block. Very similar to MPEG4 except for a different
859 escape coding (same as H263) and more vlc tables.
861 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
863 int level, run, last, i, j, last_index;
864 int last_non_zero, sign, slevel;
865 int code, run_diff, dc_pred_dir;
867 const uint8_t *scantable;
870 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
873 rl = &rl_table[s->rl_table_index];
875 rl = &rl_table[3 + s->rl_chroma_table_index];
877 run_diff = s->msmpeg4_version>=4;
878 scantable= s->intra_scantable.permutated;
881 rl = &rl_table[3 + s->rl_table_index];
882 if(s->msmpeg4_version<=2)
886 scantable= s->inter_scantable.permutated;
889 /* recalculate block_last_index for M$ wmv1 */
890 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
891 for(last_index=63; last_index>=0; last_index--){
892 if(block[scantable[last_index]]) break;
894 s->block_last_index[n]= last_index;
896 last_index = s->block_last_index[n];
898 last_non_zero = i - 1;
899 for (; i <= last_index; i++) {
903 run = i - last_non_zero - 1;
904 last = (i == last_index);
912 if(level<=MAX_LEVEL && run<=MAX_RUN){
913 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
917 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
919 code = get_rl_index(rl, last, run, level);
920 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
924 level1 = level - rl->max_level[last][run];
927 code = get_rl_index(rl, last, run, level1);
930 put_bits(&s->pb, 1, 0);
931 if (level > MAX_LEVEL)
933 run1 = run - rl->max_run[last][level] - run_diff;
936 code = get_rl_index(rl, last, run1+1, level);
937 if (s->msmpeg4_version == 4 && code == rl->n)
939 code = get_rl_index(rl, last, run1, level);
943 put_bits(&s->pb, 1, 0);
944 put_bits(&s->pb, 1, last);
945 if(s->msmpeg4_version>=4){
946 if(s->esc3_level_length==0){
947 s->esc3_level_length=8;
948 s->esc3_run_length= 6;
949 //ESCLVLSZ + ESCRUNSZ
951 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
953 put_bits(&s->pb, 8, 3);
955 put_bits(&s->pb, s->esc3_run_length, run);
956 put_bits(&s->pb, 1, sign);
957 put_bits(&s->pb, s->esc3_level_length, level);
959 put_bits(&s->pb, 6, run);
960 put_bits(&s->pb, 8, slevel & 0xff);
964 put_bits(&s->pb, 1, 1);
965 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
966 put_bits(&s->pb, 1, sign);
970 put_bits(&s->pb, 1, 1);
971 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
972 put_bits(&s->pb, 1, sign);
975 put_bits(&s->pb, 1, sign);
982 /****************************************/
985 VLC ff_mb_non_intra_vlc[4];
986 static VLC v2_dc_lum_vlc;
987 static VLC v2_dc_chroma_vlc;
989 static VLC v2_intra_cbpc_vlc;
990 static VLC v2_mb_type_vlc;
991 static VLC v2_mv_vlc;
992 static VLC v1_intra_cbpc_vlc;
993 static VLC v1_inter_cbpc_vlc;
994 VLC ff_inter_intra_vlc;
996 /* This table is practically identical to the one from h263
997 * except that it is inverted. */
998 static void init_h263_dc_for_msmpeg4(void)
1000 int level, uni_code, uni_len;
1002 for(level=-256; level<256; level++){
1004 /* find number of bits */
1013 l= (-level) ^ ((1 << size) - 1);
1017 /* luminance h263 */
1018 uni_code= DCtab_lum[size][0];
1019 uni_len = DCtab_lum[size][1];
1020 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1023 uni_code<<=size; uni_code|=l;
1026 uni_code<<=1; uni_code|=1;
1030 v2_dc_lum_table[level+256][0]= uni_code;
1031 v2_dc_lum_table[level+256][1]= uni_len;
1033 /* chrominance h263 */
1034 uni_code= DCtab_chrom[size][0];
1035 uni_len = DCtab_chrom[size][1];
1036 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1039 uni_code<<=size; uni_code|=l;
1042 uni_code<<=1; uni_code|=1;
1046 v2_dc_chroma_table[level+256][0]= uni_code;
1047 v2_dc_chroma_table[level+256][1]= uni_len;
1052 /* init all vlc decoding tables */
1053 int ff_msmpeg4_decode_init(MpegEncContext *s)
1055 static int done = 0;
1064 for(i=0;i<NB_RL_TABLES;i++) {
1065 init_rl(&rl_table[i], static_rl_table_store[i]);
1066 init_vlc_rl(&rl_table[i], 1);
1070 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1071 mv->table_mv_bits, 1, 1,
1072 mv->table_mv_code, 2, 2, 1);
1075 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1076 &ff_table0_dc_lum[0][1], 8, 4,
1077 &ff_table0_dc_lum[0][0], 8, 4, 1);
1078 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1079 &ff_table0_dc_chroma[0][1], 8, 4,
1080 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1081 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1082 &ff_table1_dc_lum[0][1], 8, 4,
1083 &ff_table1_dc_lum[0][0], 8, 4, 1);
1084 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1085 &ff_table1_dc_chroma[0][1], 8, 4,
1086 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1088 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1089 &v2_dc_lum_table[0][1], 8, 4,
1090 &v2_dc_lum_table[0][0], 8, 4, 1);
1091 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1092 &v2_dc_chroma_table[0][1], 8, 4,
1093 &v2_dc_chroma_table[0][0], 8, 4, 1);
1095 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1096 &cbpy_tab[0][1], 2, 1,
1097 &cbpy_tab[0][0], 2, 1, 1);
1098 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1099 &v2_intra_cbpc[0][1], 2, 1,
1100 &v2_intra_cbpc[0][0], 2, 1, 1);
1101 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1102 &v2_mb_type[0][1], 2, 1,
1103 &v2_mb_type[0][0], 2, 1, 1);
1104 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1106 &mvtab[0][0], 2, 1, 1);
1109 init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1110 &wmv2_inter_table[i][0][1], 8, 4,
1111 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1114 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1115 &ff_msmp4_mb_i_table[0][1], 4, 2,
1116 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1118 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1119 intra_MCBPC_bits, 1, 1,
1120 intra_MCBPC_code, 1, 1, 1);
1121 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1122 inter_MCBPC_bits, 1, 1,
1123 inter_MCBPC_code, 1, 1, 1);
1125 init_vlc(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1126 &table_inter_intra[0][1], 2, 1,
1127 &table_inter_intra[0][0], 2, 1, 1);
1130 switch(s->msmpeg4_version){
1133 s->decode_mb= msmpeg4v12_decode_mb;
1137 s->decode_mb= msmpeg4v34_decode_mb;
1140 if (ENABLE_WMV2_DECODER)
1141 s->decode_mb= ff_wmv2_decode_mb;
1143 //FIXME + TODO VC1 decode mb
1147 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1152 int msmpeg4_decode_picture_header(MpegEncContext * s)
1159 for(i=0; i<s->gb.size_in_bits; i++)
1160 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1161 // get_bits1(&s->gb);
1162 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1167 if(s->msmpeg4_version==1){
1168 int start_code, num;
1169 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1170 if(start_code!=0x00000100){
1171 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1175 num= get_bits(&s->gb, 5); // frame number */
1178 s->pict_type = get_bits(&s->gb, 2) + 1;
1179 if (s->pict_type != FF_I_TYPE &&
1180 s->pict_type != FF_P_TYPE){
1181 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1187 if(s->pict_type == FF_I_TYPE) had_i=1;
1188 if(!had_i) return -1;
1191 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1193 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1197 if (s->pict_type == FF_I_TYPE) {
1198 code = get_bits(&s->gb, 5);
1199 if(s->msmpeg4_version==1){
1200 if(code==0 || code>s->mb_height){
1201 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1205 s->slice_height = code;
1207 /* 0x17: one slice, 0x18: two slices, ... */
1209 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1213 s->slice_height = s->mb_height / (code - 0x16);
1216 switch(s->msmpeg4_version){
1219 s->rl_chroma_table_index = 2;
1220 s->rl_table_index = 2;
1222 s->dc_table_index = 0; //not used
1225 s->rl_chroma_table_index = decode012(&s->gb);
1226 s->rl_table_index = decode012(&s->gb);
1228 s->dc_table_index = get_bits1(&s->gb);
1231 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1233 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1234 else s->per_mb_rl_table= 0;
1236 if(!s->per_mb_rl_table){
1237 s->rl_chroma_table_index = decode012(&s->gb);
1238 s->rl_table_index = decode012(&s->gb);
1241 s->dc_table_index = get_bits1(&s->gb);
1242 s->inter_intra_pred= 0;
1246 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1247 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1249 s->rl_chroma_table_index,
1255 switch(s->msmpeg4_version){
1258 if(s->msmpeg4_version==1)
1259 s->use_skip_mb_code = 1;
1261 s->use_skip_mb_code = get_bits1(&s->gb);
1262 s->rl_table_index = 2;
1263 s->rl_chroma_table_index = s->rl_table_index;
1264 s->dc_table_index = 0; //not used
1265 s->mv_table_index = 0;
1268 s->use_skip_mb_code = get_bits1(&s->gb);
1269 s->rl_table_index = decode012(&s->gb);
1270 s->rl_chroma_table_index = s->rl_table_index;
1272 s->dc_table_index = get_bits1(&s->gb);
1274 s->mv_table_index = get_bits1(&s->gb);
1277 s->use_skip_mb_code = get_bits1(&s->gb);
1279 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1280 else s->per_mb_rl_table= 0;
1282 if(!s->per_mb_rl_table){
1283 s->rl_table_index = decode012(&s->gb);
1284 s->rl_chroma_table_index = s->rl_table_index;
1287 s->dc_table_index = get_bits1(&s->gb);
1289 s->mv_table_index = get_bits1(&s->gb);
1290 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1294 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1295 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1296 s->use_skip_mb_code,
1298 s->rl_chroma_table_index,
1304 if(s->flipflop_rounding){
1305 s->no_rounding ^= 1;
1310 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1312 s->esc3_level_length= 0;
1313 s->esc3_run_length= 0;
1316 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1321 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1323 int left= buf_size*8 - get_bits_count(&s->gb);
1324 int length= s->msmpeg4_version>=3 ? 17 : 16;
1325 /* the alt_bitstream reader could read over the end so we need to check it */
1326 if(left>=length && left<length+8)
1330 fps= get_bits(&s->gb, 5);
1331 s->bit_rate= get_bits(&s->gb, 11)*1024;
1332 if(s->msmpeg4_version>=3)
1333 s->flipflop_rounding= get_bits1(&s->gb);
1335 s->flipflop_rounding= 0;
1337 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1339 else if(left<length+8)
1341 s->flipflop_rounding= 0;
1342 if(s->msmpeg4_version != 2)
1343 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1347 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1353 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1360 #ifdef CONFIG_ENCODERS
1361 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1363 int range, bit_size, sign, code, bits;
1368 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1370 bit_size = s->f_code - 1;
1371 range = 1 << bit_size;
1384 code = (val >> bit_size) + 1;
1385 bits = val & (range - 1);
1387 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1389 put_bits(&s->pb, bit_size, bits);
1395 /* This is identical to h263 except that its range is multiplied by 2. */
1396 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1398 int code, val, sign, shift;
1400 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1401 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1407 sign = get_bits1(&s->gb);
1411 val = (val - 1) << shift;
1412 val |= get_bits(&s->gb, shift);
1427 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1431 if (s->pict_type == FF_P_TYPE) {
1432 if (s->use_skip_mb_code) {
1433 if (get_bits1(&s->gb)) {
1437 s->block_last_index[i] = -1;
1438 s->mv_dir = MV_DIR_FORWARD;
1439 s->mv_type = MV_TYPE_16X16;
1447 if(s->msmpeg4_version==2)
1448 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1450 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1451 if(code<0 || code>7){
1452 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1456 s->mb_intra = code >>2;
1461 if(s->msmpeg4_version==2)
1462 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1464 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1466 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1474 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1476 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1481 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1483 h263_pred_motion(s, 0, 0, &mx, &my);
1484 mx= msmpeg4v2_decode_motion(s, mx, 1);
1485 my= msmpeg4v2_decode_motion(s, my, 1);
1487 s->mv_dir = MV_DIR_FORWARD;
1488 s->mv_type = MV_TYPE_16X16;
1489 s->mv[0][0][0] = mx;
1490 s->mv[0][0][1] = my;
1492 if(s->msmpeg4_version==2){
1493 s->ac_pred = get_bits1(&s->gb);
1494 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1497 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1498 if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1502 s->dsp.clear_blocks(s->block[0]);
1503 for (i = 0; i < 6; i++) {
1504 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1506 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1513 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1517 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1519 if (s->pict_type == FF_P_TYPE) {
1520 if (s->use_skip_mb_code) {
1521 if (get_bits1(&s->gb)) {
1525 s->block_last_index[i] = -1;
1526 s->mv_dir = MV_DIR_FORWARD;
1527 s->mv_type = MV_TYPE_16X16;
1531 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1537 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1540 //s->mb_intra = (code & 0x40) ? 0 : 1;
1541 s->mb_intra = (~code & 0x40) >> 6;
1546 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1549 /* predict coded block pattern */
1552 int val = ((code >> (5 - i)) & 1);
1554 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1558 cbp |= val << (5 - i);
1564 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1565 if(s->per_mb_rl_table && cbp){
1566 s->rl_table_index = decode012(&s->gb);
1567 s->rl_chroma_table_index = s->rl_table_index;
1569 h263_pred_motion(s, 0, 0, &mx, &my);
1570 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1572 s->mv_dir = MV_DIR_FORWARD;
1573 s->mv_type = MV_TYPE_16X16;
1574 s->mv[0][0][0] = mx;
1575 s->mv[0][0][1] = my;
1576 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1578 //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));
1579 s->ac_pred = get_bits1(&s->gb);
1580 *mb_type_ptr = MB_TYPE_INTRA;
1581 if(s->inter_intra_pred){
1582 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1583 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1585 if(s->per_mb_rl_table && cbp){
1586 s->rl_table_index = decode012(&s->gb);
1587 s->rl_chroma_table_index = s->rl_table_index;
1591 s->dsp.clear_blocks(s->block[0]);
1592 for (i = 0; i < 6; i++) {
1593 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1595 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1602 //#define ERROR_DETAILS
1603 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1604 int n, int coded, const uint8_t *scan_table)
1606 int level, i, last, run, run_diff;
1609 RL_VLC_ELEM *rl_vlc;
1617 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1620 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1621 if(s->inter_intra_pred) level=0;
1625 rl = &rl_table[s->rl_table_index];
1626 if(level > 256*s->y_dc_scale){
1627 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1628 if(!s->inter_intra_pred) return -1;
1631 rl = &rl_table[3 + s->rl_chroma_table_index];
1632 if(level > 256*s->c_dc_scale){
1633 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1634 if(!s->inter_intra_pred) return -1;
1639 run_diff = s->msmpeg4_version >= 4;
1645 if (dc_pred_dir == 0)
1646 scan_table = s->intra_v_scantable.permutated; /* left */
1648 scan_table = s->intra_h_scantable.permutated; /* top */
1650 scan_table = s->intra_scantable.permutated;
1652 rl_vlc= rl->rl_vlc[0];
1654 qmul = s->qscale << 1;
1655 qadd = (s->qscale - 1) | 1;
1657 rl = &rl_table[3 + s->rl_table_index];
1659 if(s->msmpeg4_version==2)
1665 s->block_last_index[n] = i;
1669 scan_table = s->inter_scantable.permutated;
1670 rl_vlc= rl->rl_vlc[s->qscale];
1673 OPEN_READER(re, &s->gb);
1675 UPDATE_CACHE(re, &s->gb);
1676 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1679 cache= GET_CACHE(re, &s->gb);
1681 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1682 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1684 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1685 UPDATE_CACHE(re, &s->gb);
1686 if(s->msmpeg4_version<=3){
1687 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1688 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1689 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1690 SKIP_COUNTER(re, &s->gb, 1+6+8);
1693 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1694 if(!s->esc3_level_length){
1696 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1698 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1700 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");
1701 SKIP_BITS(re, &s->gb, 1);
1706 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1708 SKIP_BITS(re, &s->gb, 1);
1710 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1713 s->esc3_level_length= ll;
1714 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1715 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1716 UPDATE_CACHE(re, &s->gb);
1718 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1719 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1721 sign= SHOW_UBITS(re, &s->gb, 1);
1722 SKIP_BITS(re, &s->gb, 1);
1724 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1725 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1726 if(sign) level= -level;
1728 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1729 #if 0 // waste of time / this will detect very few errors
1731 const int abs_level= FFABS(level);
1732 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1733 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1734 if(abs_level <= rl->max_level[last][run]){
1735 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1736 return DECODING_AC_LOST;
1738 if(abs_level <= rl->max_level[last][run]*2){
1739 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1740 return DECODING_AC_LOST;
1742 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1743 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1744 return DECODING_AC_LOST;
1749 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1750 if (level>0) level= level * qmul + qadd;
1751 else level= level * qmul - qadd;
1752 #if 0 // waste of time too :(
1753 if(level>2048 || level<-2048){
1754 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1755 return DECODING_AC_LOST;
1760 #ifdef ERROR_DETAILS
1762 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1763 else if((i>62 && i<192) || i>192+63)
1764 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1768 #if MIN_CACHE_BITS < 23
1769 LAST_SKIP_BITS(re, &s->gb, 2);
1770 UPDATE_CACHE(re, &s->gb);
1772 SKIP_BITS(re, &s->gb, 2);
1774 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1775 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1776 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1777 LAST_SKIP_BITS(re, &s->gb, 1);
1778 #ifdef ERROR_DETAILS
1780 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1781 else if((i>62 && i<192) || i>192+63)
1782 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1787 #if MIN_CACHE_BITS < 22
1788 LAST_SKIP_BITS(re, &s->gb, 1);
1789 UPDATE_CACHE(re, &s->gb);
1791 SKIP_BITS(re, &s->gb, 1);
1793 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1795 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1796 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1797 LAST_SKIP_BITS(re, &s->gb, 1);
1798 #ifdef ERROR_DETAILS
1800 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1801 else if((i>62 && i<192) || i>192+63)
1802 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1807 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1808 LAST_SKIP_BITS(re, &s->gb, 1);
1809 #ifdef ERROR_DETAILS
1811 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1812 else if((i>62 && i<192) || i>192+63)
1813 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1819 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1820 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1821 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1824 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1829 block[scan_table[i]] = level;
1833 block[scan_table[i]] = level;
1835 CLOSE_READER(re, &s->gb);
1839 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1841 i = 63; /* XXX: not optimal */
1844 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1845 s->block_last_index[n] = i;
1850 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1854 if(s->msmpeg4_version<=2){
1856 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1858 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1863 }else{ //FIXME optimize use unified tables & index
1865 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1867 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1870 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1874 if (level == DC_MAX) {
1875 level = get_bits(&s->gb, 8);
1876 if (get_bits1(&s->gb))
1878 } else if (level != 0) {
1879 if (get_bits1(&s->gb))
1884 if(s->msmpeg4_version==1){
1886 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1889 /* update predictor */
1893 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1896 /* update predictor */
1898 *dc_val = level * s->y_dc_scale;
1900 *dc_val = level * s->c_dc_scale;
1907 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1908 int *mx_ptr, int *my_ptr)
1913 mv = &mv_tables[s->mv_table_index];
1915 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1917 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1920 if (code == mv->n) {
1921 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1922 mx = get_bits(&s->gb, 6);
1923 my = get_bits(&s->gb, 6);
1925 mx = mv->table_mvx[code];
1926 my = mv->table_mvy[code];
1931 /* WARNING : they do not do exactly modulo encoding */