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"
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 void ff_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 it is 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 void ff_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 void ff_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)
319 ff_find_best_tables(s);
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 ff_code012(&s->pb, s->rl_chroma_table_index);
351 ff_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 ff_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 literally */
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 ff_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 ff_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)
788 if(s->msmpeg4_version==1){
790 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
792 /* update predictor */
796 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
798 /* update predictor */
800 *dc_val = level * s->y_dc_scale;
802 *dc_val = level * s->c_dc_scale;
806 /* do the prediction */
809 if(s->msmpeg4_version<=2){
812 v2_dc_lum_table[level+256][1],
813 v2_dc_lum_table[level+256][0]);
816 v2_dc_chroma_table[level+256][1],
817 v2_dc_chroma_table[level+256][0]);
828 else if( s->msmpeg4_version>=6 ) {
829 if( s->qscale == 1 ) {
830 extquant = (level + 3) & 0x3;
831 code = ((level+3)>>2);
832 } else if( s->qscale == 2 ) {
833 extquant = (level + 1) & 0x1;
834 code = ((level+1)>>1);
838 if (s->dc_table_index == 0) {
840 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
842 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
846 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
848 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
852 if(s->msmpeg4_version>=6 && s->qscale<=2)
853 extrabits = 3 - s->qscale;
856 put_bits(&s->pb, 8 + extrabits, level);
857 else if(extrabits > 0)//== VC1 && s->qscale<=2
858 put_bits(&s->pb, extrabits, extquant);
861 put_bits(&s->pb, 1, sign);
866 /* Encoding of a block. Very similar to MPEG4 except for a different
867 escape coding (same as H263) and more vlc tables.
869 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
871 int level, run, last, i, j, last_index;
872 int last_non_zero, sign, slevel;
873 int code, run_diff, dc_pred_dir;
875 const uint8_t *scantable;
878 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
881 rl = &rl_table[s->rl_table_index];
883 rl = &rl_table[3 + s->rl_chroma_table_index];
885 run_diff = s->msmpeg4_version>=4;
886 scantable= s->intra_scantable.permutated;
889 rl = &rl_table[3 + s->rl_table_index];
890 if(s->msmpeg4_version<=2)
894 scantable= s->inter_scantable.permutated;
897 /* recalculate block_last_index for M$ wmv1 */
898 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
899 for(last_index=63; last_index>=0; last_index--){
900 if(block[scantable[last_index]]) break;
902 s->block_last_index[n]= last_index;
904 last_index = s->block_last_index[n];
906 last_non_zero = i - 1;
907 for (; i <= last_index; i++) {
911 run = i - last_non_zero - 1;
912 last = (i == last_index);
920 if(level<=MAX_LEVEL && run<=MAX_RUN){
921 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
925 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
927 code = get_rl_index(rl, last, run, level);
928 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
932 level1 = level - rl->max_level[last][run];
935 code = get_rl_index(rl, last, run, level1);
938 put_bits(&s->pb, 1, 0);
939 if (level > MAX_LEVEL)
941 run1 = run - rl->max_run[last][level] - run_diff;
944 code = get_rl_index(rl, last, run1+1, level);
945 if (s->msmpeg4_version == 4 && code == rl->n)
947 code = get_rl_index(rl, last, run1, level);
951 put_bits(&s->pb, 1, 0);
952 put_bits(&s->pb, 1, last);
953 if(s->msmpeg4_version>=4){
954 if(s->esc3_level_length==0){
955 s->esc3_level_length=8;
956 s->esc3_run_length= 6;
957 //ESCLVLSZ + ESCRUNSZ
959 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
961 put_bits(&s->pb, 8, 3);
963 put_bits(&s->pb, s->esc3_run_length, run);
964 put_bits(&s->pb, 1, sign);
965 put_bits(&s->pb, s->esc3_level_length, level);
967 put_bits(&s->pb, 6, run);
968 put_bits(&s->pb, 8, slevel & 0xff);
972 put_bits(&s->pb, 1, 1);
973 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
974 put_bits(&s->pb, 1, sign);
978 put_bits(&s->pb, 1, 1);
979 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
980 put_bits(&s->pb, 1, sign);
983 put_bits(&s->pb, 1, sign);
990 /****************************************/
993 static VLC mb_non_intra_vlc[4];
994 static VLC v2_dc_lum_vlc;
995 static VLC v2_dc_chroma_vlc;
997 static VLC v2_intra_cbpc_vlc;
998 static VLC v2_mb_type_vlc;
999 static VLC v2_mv_vlc;
1000 static VLC v1_intra_cbpc_vlc;
1001 static VLC v1_inter_cbpc_vlc;
1002 static VLC inter_intra_vlc;
1004 /* This table is practically identical to the one from h263
1005 * except that it is inverted. */
1006 static void init_h263_dc_for_msmpeg4(void)
1008 int level, uni_code, uni_len;
1010 for(level=-256; level<256; level++){
1012 /* find number of bits */
1021 l= (-level) ^ ((1 << size) - 1);
1025 /* luminance h263 */
1026 uni_code= DCtab_lum[size][0];
1027 uni_len = DCtab_lum[size][1];
1028 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1031 uni_code<<=size; uni_code|=l;
1034 uni_code<<=1; uni_code|=1;
1038 v2_dc_lum_table[level+256][0]= uni_code;
1039 v2_dc_lum_table[level+256][1]= uni_len;
1041 /* chrominance h263 */
1042 uni_code= DCtab_chrom[size][0];
1043 uni_len = DCtab_chrom[size][1];
1044 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1047 uni_code<<=size; uni_code|=l;
1050 uni_code<<=1; uni_code|=1;
1054 v2_dc_chroma_table[level+256][0]= uni_code;
1055 v2_dc_chroma_table[level+256][1]= uni_len;
1060 /* init all vlc decoding tables */
1061 int ff_msmpeg4_decode_init(MpegEncContext *s)
1063 static int done = 0;
1072 for(i=0;i<NB_RL_TABLES;i++) {
1073 init_rl(&rl_table[i], static_rl_table_store[i]);
1074 init_vlc_rl(&rl_table[i], 1);
1078 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1079 mv->table_mv_bits, 1, 1,
1080 mv->table_mv_code, 2, 2, 1);
1083 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1084 &ff_table0_dc_lum[0][1], 8, 4,
1085 &ff_table0_dc_lum[0][0], 8, 4, 1);
1086 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1087 &ff_table0_dc_chroma[0][1], 8, 4,
1088 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1089 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1090 &ff_table1_dc_lum[0][1], 8, 4,
1091 &ff_table1_dc_lum[0][0], 8, 4, 1);
1092 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1093 &ff_table1_dc_chroma[0][1], 8, 4,
1094 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1096 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1097 &v2_dc_lum_table[0][1], 8, 4,
1098 &v2_dc_lum_table[0][0], 8, 4, 1);
1099 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1100 &v2_dc_chroma_table[0][1], 8, 4,
1101 &v2_dc_chroma_table[0][0], 8, 4, 1);
1103 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1104 &cbpy_tab[0][1], 2, 1,
1105 &cbpy_tab[0][0], 2, 1, 1);
1106 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1107 &v2_intra_cbpc[0][1], 2, 1,
1108 &v2_intra_cbpc[0][0], 2, 1, 1);
1109 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1110 &v2_mb_type[0][1], 2, 1,
1111 &v2_mb_type[0][0], 2, 1, 1);
1112 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1114 &mvtab[0][0], 2, 1, 1);
1117 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1118 &wmv2_inter_table[i][0][1], 8, 4,
1119 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1122 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1123 &ff_msmp4_mb_i_table[0][1], 4, 2,
1124 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1126 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1127 intra_MCBPC_bits, 1, 1,
1128 intra_MCBPC_code, 1, 1, 1);
1129 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1130 inter_MCBPC_bits, 1, 1,
1131 inter_MCBPC_code, 1, 1, 1);
1133 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1134 &table_inter_intra[0][1], 2, 1,
1135 &table_inter_intra[0][0], 2, 1, 1);
1138 switch(s->msmpeg4_version){
1141 s->decode_mb= msmpeg4v12_decode_mb;
1145 s->decode_mb= msmpeg4v34_decode_mb;
1148 s->decode_mb= wmv2_decode_mb;
1150 //FIXME + TODO VC1 decode mb
1154 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1159 int msmpeg4_decode_picture_header(MpegEncContext * s)
1166 for(i=0; i<s->gb.size_in_bits; i++)
1167 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1168 // get_bits1(&s->gb);
1169 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1174 if(s->msmpeg4_version==1){
1175 int start_code, num;
1176 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1177 if(start_code!=0x00000100){
1178 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1182 num= get_bits(&s->gb, 5); // frame number */
1185 s->pict_type = get_bits(&s->gb, 2) + 1;
1186 if (s->pict_type != I_TYPE &&
1187 s->pict_type != P_TYPE){
1188 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1194 if(s->pict_type == I_TYPE) had_i=1;
1195 if(!had_i) return -1;
1198 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1200 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1204 if (s->pict_type == I_TYPE) {
1205 code = get_bits(&s->gb, 5);
1206 if(s->msmpeg4_version==1){
1207 if(code==0 || code>s->mb_height){
1208 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1212 s->slice_height = code;
1214 /* 0x17: one slice, 0x18: two slices, ... */
1216 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1220 s->slice_height = s->mb_height / (code - 0x16);
1223 switch(s->msmpeg4_version){
1226 s->rl_chroma_table_index = 2;
1227 s->rl_table_index = 2;
1229 s->dc_table_index = 0; //not used
1232 s->rl_chroma_table_index = decode012(&s->gb);
1233 s->rl_table_index = decode012(&s->gb);
1235 s->dc_table_index = get_bits1(&s->gb);
1238 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1240 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1241 else s->per_mb_rl_table= 0;
1243 if(!s->per_mb_rl_table){
1244 s->rl_chroma_table_index = decode012(&s->gb);
1245 s->rl_table_index = decode012(&s->gb);
1248 s->dc_table_index = get_bits1(&s->gb);
1249 s->inter_intra_pred= 0;
1253 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1254 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1256 s->rl_chroma_table_index,
1262 switch(s->msmpeg4_version){
1265 if(s->msmpeg4_version==1)
1266 s->use_skip_mb_code = 1;
1268 s->use_skip_mb_code = get_bits1(&s->gb);
1269 s->rl_table_index = 2;
1270 s->rl_chroma_table_index = s->rl_table_index;
1271 s->dc_table_index = 0; //not used
1272 s->mv_table_index = 0;
1275 s->use_skip_mb_code = get_bits1(&s->gb);
1276 s->rl_table_index = decode012(&s->gb);
1277 s->rl_chroma_table_index = s->rl_table_index;
1279 s->dc_table_index = get_bits1(&s->gb);
1281 s->mv_table_index = get_bits1(&s->gb);
1284 s->use_skip_mb_code = get_bits1(&s->gb);
1286 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1287 else s->per_mb_rl_table= 0;
1289 if(!s->per_mb_rl_table){
1290 s->rl_table_index = decode012(&s->gb);
1291 s->rl_chroma_table_index = s->rl_table_index;
1294 s->dc_table_index = get_bits1(&s->gb);
1296 s->mv_table_index = get_bits1(&s->gb);
1297 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1301 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1302 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1303 s->use_skip_mb_code,
1305 s->rl_chroma_table_index,
1311 if(s->flipflop_rounding){
1312 s->no_rounding ^= 1;
1317 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1319 s->esc3_level_length= 0;
1320 s->esc3_run_length= 0;
1323 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1328 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1330 int left= buf_size*8 - get_bits_count(&s->gb);
1331 int length= s->msmpeg4_version>=3 ? 17 : 16;
1332 /* the alt_bitstream reader could read over the end so we need to check it */
1333 if(left>=length && left<length+8)
1337 fps= get_bits(&s->gb, 5);
1338 s->bit_rate= get_bits(&s->gb, 11)*1024;
1339 if(s->msmpeg4_version>=3)
1340 s->flipflop_rounding= get_bits1(&s->gb);
1342 s->flipflop_rounding= 0;
1344 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1346 else if(left<length+8)
1348 s->flipflop_rounding= 0;
1349 if(s->msmpeg4_version != 2)
1350 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1354 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1360 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1367 #ifdef CONFIG_ENCODERS
1368 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1370 int range, bit_size, sign, code, bits;
1375 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1377 bit_size = s->f_code - 1;
1378 range = 1 << bit_size;
1391 code = (val >> bit_size) + 1;
1392 bits = val & (range - 1);
1394 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1396 put_bits(&s->pb, bit_size, bits);
1402 /* This is identical to h263 except that its range is multiplied by 2. */
1403 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1405 int code, val, sign, shift;
1407 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1408 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1414 sign = get_bits1(&s->gb);
1418 val = (val - 1) << shift;
1419 val |= get_bits(&s->gb, shift);
1434 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1438 if (s->pict_type == P_TYPE) {
1439 if (s->use_skip_mb_code) {
1440 if (get_bits1(&s->gb)) {
1444 s->block_last_index[i] = -1;
1445 s->mv_dir = MV_DIR_FORWARD;
1446 s->mv_type = MV_TYPE_16X16;
1454 if(s->msmpeg4_version==2)
1455 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1457 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1458 if(code<0 || code>7){
1459 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1463 s->mb_intra = code >>2;
1468 if(s->msmpeg4_version==2)
1469 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1471 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1473 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1481 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1483 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1488 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1490 h263_pred_motion(s, 0, 0, &mx, &my);
1491 mx= msmpeg4v2_decode_motion(s, mx, 1);
1492 my= msmpeg4v2_decode_motion(s, my, 1);
1494 s->mv_dir = MV_DIR_FORWARD;
1495 s->mv_type = MV_TYPE_16X16;
1496 s->mv[0][0][0] = mx;
1497 s->mv[0][0][1] = my;
1499 if(s->msmpeg4_version==2){
1500 s->ac_pred = get_bits1(&s->gb);
1501 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1504 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1505 if(s->pict_type==P_TYPE) cbp^=0x3C;
1509 s->dsp.clear_blocks(s->block[0]);
1510 for (i = 0; i < 6; i++) {
1511 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1513 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1520 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1524 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1526 if (s->pict_type == P_TYPE) {
1527 if (s->use_skip_mb_code) {
1528 if (get_bits1(&s->gb)) {
1532 s->block_last_index[i] = -1;
1533 s->mv_dir = MV_DIR_FORWARD;
1534 s->mv_type = MV_TYPE_16X16;
1538 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1544 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1547 //s->mb_intra = (code & 0x40) ? 0 : 1;
1548 s->mb_intra = (~code & 0x40) >> 6;
1553 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1556 /* predict coded block pattern */
1559 int val = ((code >> (5 - i)) & 1);
1561 int pred = coded_block_pred(s, i, &coded_val);
1565 cbp |= val << (5 - i);
1571 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1572 if(s->per_mb_rl_table && cbp){
1573 s->rl_table_index = decode012(&s->gb);
1574 s->rl_chroma_table_index = s->rl_table_index;
1576 h263_pred_motion(s, 0, 0, &mx, &my);
1577 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1579 s->mv_dir = MV_DIR_FORWARD;
1580 s->mv_type = MV_TYPE_16X16;
1581 s->mv[0][0][0] = mx;
1582 s->mv[0][0][1] = my;
1583 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1585 //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));
1586 s->ac_pred = get_bits1(&s->gb);
1587 *mb_type_ptr = MB_TYPE_INTRA;
1588 if(s->inter_intra_pred){
1589 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1590 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1592 if(s->per_mb_rl_table && cbp){
1593 s->rl_table_index = decode012(&s->gb);
1594 s->rl_chroma_table_index = s->rl_table_index;
1598 s->dsp.clear_blocks(s->block[0]);
1599 for (i = 0; i < 6; i++) {
1600 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1602 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1609 //#define ERROR_DETAILS
1610 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1611 int n, int coded, const uint8_t *scan_table)
1613 int level, i, last, run, run_diff;
1616 RL_VLC_ELEM *rl_vlc;
1624 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1627 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1628 if(s->inter_intra_pred) level=0;
1632 rl = &rl_table[s->rl_table_index];
1633 if(level > 256*s->y_dc_scale){
1634 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1635 if(!s->inter_intra_pred) return -1;
1638 rl = &rl_table[3 + s->rl_chroma_table_index];
1639 if(level > 256*s->c_dc_scale){
1640 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1641 if(!s->inter_intra_pred) return -1;
1646 run_diff = s->msmpeg4_version >= 4;
1652 if (dc_pred_dir == 0)
1653 scan_table = s->intra_v_scantable.permutated; /* left */
1655 scan_table = s->intra_h_scantable.permutated; /* top */
1657 scan_table = s->intra_scantable.permutated;
1659 rl_vlc= rl->rl_vlc[0];
1661 qmul = s->qscale << 1;
1662 qadd = (s->qscale - 1) | 1;
1664 rl = &rl_table[3 + s->rl_table_index];
1666 if(s->msmpeg4_version==2)
1672 s->block_last_index[n] = i;
1676 scan_table = s->inter_scantable.permutated;
1677 rl_vlc= rl->rl_vlc[s->qscale];
1680 OPEN_READER(re, &s->gb);
1682 UPDATE_CACHE(re, &s->gb);
1683 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1686 cache= GET_CACHE(re, &s->gb);
1688 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1689 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1691 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1692 UPDATE_CACHE(re, &s->gb);
1693 if(s->msmpeg4_version<=3){
1694 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1695 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1696 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1697 SKIP_COUNTER(re, &s->gb, 1+6+8);
1700 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1701 if(!s->esc3_level_length){
1703 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1705 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1707 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");
1708 SKIP_BITS(re, &s->gb, 1);
1713 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1715 SKIP_BITS(re, &s->gb, 1);
1717 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1720 s->esc3_level_length= ll;
1721 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1722 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1723 UPDATE_CACHE(re, &s->gb);
1725 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1726 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1728 sign= SHOW_UBITS(re, &s->gb, 1);
1729 SKIP_BITS(re, &s->gb, 1);
1731 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1732 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1733 if(sign) level= -level;
1735 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1736 #if 0 // waste of time / this will detect very few errors
1738 const int abs_level= FFABS(level);
1739 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1740 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1741 if(abs_level <= rl->max_level[last][run]){
1742 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1743 return DECODING_AC_LOST;
1745 if(abs_level <= rl->max_level[last][run]*2){
1746 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1747 return DECODING_AC_LOST;
1749 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1750 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1751 return DECODING_AC_LOST;
1756 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1757 if (level>0) level= level * qmul + qadd;
1758 else level= level * qmul - qadd;
1759 #if 0 // waste of time too :(
1760 if(level>2048 || level<-2048){
1761 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1762 return DECODING_AC_LOST;
1767 #ifdef ERROR_DETAILS
1769 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1770 else if((i>62 && i<192) || i>192+63)
1771 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1775 #if MIN_CACHE_BITS < 23
1776 LAST_SKIP_BITS(re, &s->gb, 2);
1777 UPDATE_CACHE(re, &s->gb);
1779 SKIP_BITS(re, &s->gb, 2);
1781 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1782 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1783 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1784 LAST_SKIP_BITS(re, &s->gb, 1);
1785 #ifdef ERROR_DETAILS
1787 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1788 else if((i>62 && i<192) || i>192+63)
1789 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1794 #if MIN_CACHE_BITS < 22
1795 LAST_SKIP_BITS(re, &s->gb, 1);
1796 UPDATE_CACHE(re, &s->gb);
1798 SKIP_BITS(re, &s->gb, 1);
1800 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1802 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1803 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1804 LAST_SKIP_BITS(re, &s->gb, 1);
1805 #ifdef ERROR_DETAILS
1807 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1808 else if((i>62 && i<192) || i>192+63)
1809 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1814 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1815 LAST_SKIP_BITS(re, &s->gb, 1);
1816 #ifdef ERROR_DETAILS
1818 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1819 else if((i>62 && i<192) || i>192+63)
1820 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1826 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1827 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1828 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1831 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1836 block[scan_table[i]] = level;
1840 block[scan_table[i]] = level;
1842 CLOSE_READER(re, &s->gb);
1846 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1848 i = 63; /* XXX: not optimal */
1851 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1852 s->block_last_index[n] = i;
1857 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1861 if(s->msmpeg4_version<=2){
1863 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1865 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1870 }else{ //FIXME optimize use unified tables & index
1872 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1874 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1877 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1881 if (level == DC_MAX) {
1882 level = get_bits(&s->gb, 8);
1883 if (get_bits1(&s->gb))
1885 } else if (level != 0) {
1886 if (get_bits1(&s->gb))
1891 if(s->msmpeg4_version==1){
1893 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1896 /* update predictor */
1900 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1903 /* update predictor */
1905 *dc_val = level * s->y_dc_scale;
1907 *dc_val = level * s->c_dc_scale;
1914 static int msmpeg4_decode_motion(MpegEncContext * s,
1915 int *mx_ptr, int *my_ptr)
1920 mv = &mv_tables[s->mv_table_index];
1922 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1924 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1927 if (code == mv->n) {
1928 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1929 mx = get_bits(&s->gb, 6);
1930 my = get_bits(&s->gb, 6);
1932 mx = mv->table_mvx[code];
1933 my = mv->table_mvy[code];
1938 /* WARNING : they do not do exactly modulo encoding */
1953 /* cleanest way to support it
1954 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1955 * as allmost everything would be in the common file