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"
89 #include "msmpeg4tab.h"
91 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if it is not references
92 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
93 #endif //CONFIG_ENCODERS
95 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
97 static void common_init(MpegEncContext * s)
101 switch(s->msmpeg4_version){
105 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
108 if(s->workaround_bugs){
109 s->y_dc_scale_table= old_ff_y_dc_scale_table;
110 s->c_dc_scale_table= old_ff_c_dc_scale_table;
112 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
113 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
118 s->y_dc_scale_table= wmv1_y_dc_scale_table;
119 s->c_dc_scale_table= wmv1_c_dc_scale_table;
121 #if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
123 s->y_dc_scale_table= wmv3_dc_scale_table;
124 s->c_dc_scale_table= wmv3_dc_scale_table;
131 if(s->msmpeg4_version>=4){
132 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
133 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
134 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
135 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
137 //Note the default tables are set in common_init in mpegvideo.c
142 init_h263_dc_for_msmpeg4();
146 #ifdef CONFIG_ENCODERS
148 /* build the table which associate a (x,y) motion vector to a vlc */
149 static void init_mv_table(MVTable *tab)
153 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
154 /* mark all entries as not used */
156 tab->table_mv_index[i] = tab->n;
158 for(i=0;i<tab->n;i++) {
159 x = tab->table_mvx[i];
160 y = tab->table_mvy[i];
161 tab->table_mv_index[(x << 6) | y] = i;
165 void ff_code012(PutBitContext *pb, int n)
171 put_bits(pb, 1, (n >= 2));
175 void ff_msmpeg4_encode_init(MpegEncContext *s)
177 static int init_done=0;
181 if(s->msmpeg4_version>=4){
187 /* init various encoding tables */
189 init_mv_table(&mv_tables[0]);
190 init_mv_table(&mv_tables[1]);
191 for(i=0;i<NB_RL_TABLES;i++)
192 init_rl(&rl_table[i], static_rl_table_store[i]);
194 for(i=0; i<NB_RL_TABLES; i++){
196 for(level=0; level<=MAX_LEVEL; level++){
198 for(run=0; run<=MAX_RUN; run++){
200 for(last=0; last<2; last++){
201 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
209 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
212 int run_diff= intra ? 0 : 1;
214 code = get_rl_index(rl, last, run, level);
215 size+= rl->table_vlc[code][1];
219 level1 = level - rl->max_level[last][run];
222 code = get_rl_index(rl, last, run, level1);
226 if (level > MAX_LEVEL)
228 run1 = run - rl->max_run[last][level] - run_diff;
231 code = get_rl_index(rl, last, run1, level);
238 size+= 1+1+ rl->table_vlc[code][1];
242 size+= 1+1+ rl->table_vlc[code][1];
250 void ff_find_best_tables(MpegEncContext * s)
253 int best =-1, best_size =9999999;
254 int chroma_best=-1, best_chroma_size=9999999;
265 for(level=0; level<=MAX_LEVEL; level++){
267 for(run=0; run<=MAX_RUN; run++){
269 const int last_size= size + chroma_size;
270 for(last=0; last<2; last++){
271 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
272 int intra_luma_count = s->ac_stats[1][0][level][run][last];
273 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
275 if(s->pict_type==I_TYPE){
276 size += intra_luma_count *rl_length[i ][level][run][last];
277 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
279 size+= intra_luma_count *rl_length[i ][level][run][last]
280 +intra_chroma_count*rl_length[i+3][level][run][last]
281 +inter_count *rl_length[i+3][level][run][last];
284 if(last_size == size+chroma_size) break;
291 if(chroma_size<best_chroma_size){
292 best_chroma_size= chroma_size;
297 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
298 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
300 if(s->pict_type==P_TYPE) chroma_best= best;
302 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
304 s->rl_table_index = best;
305 s->rl_chroma_table_index= chroma_best;
307 if(s->pict_type != s->last_non_b_pict_type){
308 s->rl_table_index= 2;
309 if(s->pict_type==I_TYPE)
310 s->rl_chroma_table_index= 1;
312 s->rl_chroma_table_index= 2;
317 /* write MSMPEG4 compatible frame header */
318 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
320 ff_find_best_tables(s);
322 align_put_bits(&s->pb);
323 put_bits(&s->pb, 2, s->pict_type - 1);
325 put_bits(&s->pb, 5, s->qscale);
326 if(s->msmpeg4_version<=2){
327 s->rl_table_index = 2;
328 s->rl_chroma_table_index = 2;
331 s->dc_table_index = 1;
332 s->mv_table_index = 1; /* only if P frame */
333 s->use_skip_mb_code = 1; /* only if P frame */
334 s->per_mb_rl_table = 0;
335 if(s->msmpeg4_version==4)
336 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
337 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
339 if (s->pict_type == I_TYPE) {
340 s->slice_height= s->mb_height/1;
341 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
343 if(s->msmpeg4_version==4){
344 msmpeg4_encode_ext_header(s);
345 if(s->bit_rate>MBAC_BITRATE)
346 put_bits(&s->pb, 1, s->per_mb_rl_table);
349 if(s->msmpeg4_version>2){
350 if(!s->per_mb_rl_table){
351 ff_code012(&s->pb, s->rl_chroma_table_index);
352 ff_code012(&s->pb, s->rl_table_index);
355 put_bits(&s->pb, 1, s->dc_table_index);
358 put_bits(&s->pb, 1, s->use_skip_mb_code);
360 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
361 put_bits(&s->pb, 1, s->per_mb_rl_table);
363 if(s->msmpeg4_version>2){
364 if(!s->per_mb_rl_table)
365 ff_code012(&s->pb, s->rl_table_index);
367 put_bits(&s->pb, 1, s->dc_table_index);
369 put_bits(&s->pb, 1, s->mv_table_index);
373 s->esc3_level_length= 0;
374 s->esc3_run_length= 0;
378 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
382 void msmpeg4_encode_ext_header(MpegEncContext * s)
384 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
386 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
388 if(s->msmpeg4_version>=3)
389 put_bits(&s->pb, 1, s->flipflop_rounding);
391 assert(s->flipflop_rounding==0);
394 #endif //CONFIG_ENCODERS
396 /* predict coded block */
397 static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
399 int xy, wrap, pred, a, b, c;
401 xy = s->block_index[n];
407 a = s->coded_block[xy - 1 ];
408 b = s->coded_block[xy - 1 - wrap];
409 c = s->coded_block[xy - wrap];
418 *coded_block_ptr = &s->coded_block[xy];
423 #ifdef CONFIG_ENCODERS
425 static void msmpeg4_encode_motion(MpegEncContext * s,
431 /* modulo encoding */
432 /* WARNING : you cannot reach all the MVs even with the modulo
433 encoding. This is a somewhat strange compromise they took !!! */
446 if ((unsigned)mx >= 64 ||
448 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
450 mv = &mv_tables[s->mv_table_index];
452 code = mv->table_mv_index[(mx << 6) | my];
454 mv->table_mv_bits[code],
455 mv->table_mv_code[code]);
457 /* escape : code literally */
458 put_bits(&s->pb, 6, mx);
459 put_bits(&s->pb, 6, my);
463 static inline void handle_slices(MpegEncContext *s){
465 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
466 if(s->msmpeg4_version < 4){
467 ff_mpeg4_clean_buffers(s);
469 s->first_slice_line = 1;
471 s->first_slice_line = 0;
476 void msmpeg4_encode_mb(MpegEncContext * s,
477 DCTELEM block[6][64],
478 int motion_x, int motion_y)
480 int cbp, coded_cbp, i;
482 uint8_t *coded_block;
489 for (i = 0; i < 6; i++) {
490 if (s->block_last_index[i] >= 0)
493 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
494 /* skip macroblock */
495 put_bits(&s->pb, 1, 1);
502 if (s->use_skip_mb_code)
503 put_bits(&s->pb, 1, 0); /* mb coded */
505 if(s->msmpeg4_version<=2){
507 v2_mb_type[cbp&3][1],
508 v2_mb_type[cbp&3][0]);
509 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
513 cbpy_tab[coded_cbp>>2][1],
514 cbpy_tab[coded_cbp>>2][0]);
516 s->misc_bits += get_bits_diff(s);
518 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
519 msmpeg4v2_encode_motion(s, motion_x - pred_x);
520 msmpeg4v2_encode_motion(s, motion_y - pred_y);
523 table_mb_non_intra[cbp + 64][1],
524 table_mb_non_intra[cbp + 64][0]);
526 s->misc_bits += get_bits_diff(s);
529 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
530 msmpeg4_encode_motion(s, motion_x - pred_x,
534 s->mv_bits += get_bits_diff(s);
536 for (i = 0; i < 6; i++) {
537 ff_msmpeg4_encode_block(s, block[i], i);
539 s->p_tex_bits += get_bits_diff(s);
544 for (i = 0; i < 6; i++) {
546 val = (s->block_last_index[i] >= 1);
547 cbp |= val << (5 - i);
549 /* predict value for close blocks only for luma */
550 pred = coded_block_pred(s, i, &coded_block);
554 coded_cbp |= val << (5 - i);
558 printf("cbp=%x %x\n", cbp, coded_cbp);
561 if(s->msmpeg4_version<=2){
562 if (s->pict_type == I_TYPE) {
564 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
566 if (s->use_skip_mb_code)
567 put_bits(&s->pb, 1, 0); /* mb coded */
569 v2_mb_type[(cbp&3) + 4][1],
570 v2_mb_type[(cbp&3) + 4][0]);
572 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
575 cbpy_tab[cbp>>2][0]);
577 if (s->pict_type == I_TYPE) {
579 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
581 if (s->use_skip_mb_code)
582 put_bits(&s->pb, 1, 0); /* mb coded */
584 table_mb_non_intra[cbp][1],
585 table_mb_non_intra[cbp][0]);
587 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
588 if(s->inter_intra_pred){
590 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
593 s->misc_bits += get_bits_diff(s);
595 for (i = 0; i < 6; i++) {
596 ff_msmpeg4_encode_block(s, block[i], i);
598 s->i_tex_bits += get_bits_diff(s);
603 #endif //CONFIG_ENCODERS
605 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
606 int32_t **dc_val_ptr)
616 *dc_val_ptr= &s->last_dc[i];
617 return s->last_dc[i];
620 static int get_dc(uint8_t *src, int stride, int scale)
627 sum+=src[x + y*stride];
630 return FASTDIV((sum + (scale>>1)), scale);
633 /* dir = 0: left, dir = 1: top prediction */
634 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
635 int16_t **dc_val_ptr, int *dir_ptr)
637 int a, b, c, wrap, pred, scale;
640 /* find prediction */
642 scale = s->y_dc_scale;
644 scale = s->c_dc_scale;
647 wrap = s->block_wrap[n];
648 dc_val= s->dc_val[0] + s->block_index[n];
654 b = dc_val[ - 1 - wrap];
657 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
661 /* XXX: the following solution consumes divisions, but it does not
662 necessitate to modify mpegvideo.c. The problem comes from the
663 fact they decided to store the quantized DC (which would lead
664 to problems if Q could vary !) */
665 #if (defined(ARCH_X86)) && !defined PIC
667 "movl %3, %%eax \n\t"
668 "shrl $1, %%eax \n\t"
669 "addl %%eax, %2 \n\t"
670 "addl %%eax, %1 \n\t"
671 "addl %0, %%eax \n\t"
673 "movl %%edx, %0 \n\t"
674 "movl %1, %%eax \n\t"
676 "movl %%edx, %1 \n\t"
677 "movl %2, %%eax \n\t"
679 "movl %%edx, %2 \n\t"
680 : "+b" (a), "+c" (b), "+D" (c)
681 : "g" (scale), "S" (ff_inverse[scale])
685 /* #elif defined (ARCH_ALPHA) */
686 /* Divisions are extremely costly on Alpha; optimize the most
687 common case. But they are costly everywhere...
690 a = (a + (8 >> 1)) / 8;
691 b = (b + (8 >> 1)) / 8;
692 c = (c + (8 >> 1)) / 8;
694 a = FASTDIV((a + (scale >> 1)), scale);
695 b = FASTDIV((b + (scale >> 1)), scale);
696 c = FASTDIV((c + (scale >> 1)), scale);
699 /* XXX: WARNING: they did not choose the same test as MPEG4. This
700 is very important ! */
701 if(s->msmpeg4_version>3){
702 if(s->inter_intra_pred){
713 if (abs(a - b) < abs(b - c)) {
723 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
726 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
728 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
729 else a= get_dc(dest-8, wrap, scale*8);
730 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
731 else c= get_dc(dest-8*wrap, wrap, scale*8);
733 if (s->h263_aic_dir==0) {
736 }else if (s->h263_aic_dir==1) {
744 }else if (s->h263_aic_dir==2) {
758 if (abs(a - b) < abs(b - c)) {
767 if (abs(a - b) <= abs(b - c)) {
776 /* update predictor */
777 *dc_val_ptr = &dc_val[0];
783 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
789 if(s->msmpeg4_version==1){
791 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
793 /* update predictor */
797 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
799 /* update predictor */
801 *dc_val = level * s->y_dc_scale;
803 *dc_val = level * s->c_dc_scale;
807 /* do the prediction */
810 if(s->msmpeg4_version<=2){
813 v2_dc_lum_table[level+256][1],
814 v2_dc_lum_table[level+256][0]);
817 v2_dc_chroma_table[level+256][1],
818 v2_dc_chroma_table[level+256][0]);
829 else if( s->msmpeg4_version>=6 ) {
830 if( s->qscale == 1 ) {
831 extquant = (level + 3) & 0x3;
832 code = ((level+3)>>2);
833 } else if( s->qscale == 2 ) {
834 extquant = (level + 1) & 0x1;
835 code = ((level+1)>>1);
839 if (s->dc_table_index == 0) {
841 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
843 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
847 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
849 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
853 if(s->msmpeg4_version>=6 && s->qscale<=2)
854 extrabits = 3 - s->qscale;
857 put_bits(&s->pb, 8 + extrabits, level);
858 else if(extrabits > 0)//== VC1 && s->qscale<=2
859 put_bits(&s->pb, extrabits, extquant);
862 put_bits(&s->pb, 1, sign);
867 /* Encoding of a block. Very similar to MPEG4 except for a different
868 escape coding (same as H263) and more vlc tables.
870 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
872 int level, run, last, i, j, last_index;
873 int last_non_zero, sign, slevel;
874 int code, run_diff, dc_pred_dir;
876 const uint8_t *scantable;
879 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
882 rl = &rl_table[s->rl_table_index];
884 rl = &rl_table[3 + s->rl_chroma_table_index];
886 run_diff = s->msmpeg4_version>=6;
887 scantable= s->intra_scantable.permutated;
890 rl = &rl_table[3 + s->rl_table_index];
891 if(s->msmpeg4_version<=2)
895 scantable= s->inter_scantable.permutated;
898 /* recalculate block_last_index for M$ wmv1 */
899 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
900 for(last_index=63; last_index>=0; last_index--){
901 if(block[scantable[last_index]]) break;
903 s->block_last_index[n]= last_index;
905 last_index = s->block_last_index[n];
907 last_non_zero = i - 1;
908 for (; i <= last_index; i++) {
912 run = i - last_non_zero - 1;
913 last = (i == last_index);
921 if(level<=MAX_LEVEL && run<=MAX_RUN){
922 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
926 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
928 code = get_rl_index(rl, last, run, level);
929 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
933 level1 = level - rl->max_level[last][run];
936 code = get_rl_index(rl, last, run, level1);
939 put_bits(&s->pb, 1, 0);
940 if (level > MAX_LEVEL)
942 run1 = run - rl->max_run[last][level] - run_diff;
945 code = get_rl_index(rl, last, run1, level);
949 put_bits(&s->pb, 1, 0);
950 put_bits(&s->pb, 1, last);
951 if(s->msmpeg4_version>=4){
952 if(s->esc3_level_length==0){
953 s->esc3_level_length=8;
954 s->esc3_run_length= 6;
955 //ESCLVLSZ + ESCRUNSZ
957 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
959 put_bits(&s->pb, 8, 3);
961 put_bits(&s->pb, s->esc3_run_length, run);
962 put_bits(&s->pb, 1, sign);
963 put_bits(&s->pb, s->esc3_level_length, level);
965 put_bits(&s->pb, 6, run);
966 put_bits(&s->pb, 8, slevel & 0xff);
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);
976 put_bits(&s->pb, 1, 1);
977 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
978 put_bits(&s->pb, 1, sign);
981 put_bits(&s->pb, 1, sign);
988 /****************************************/
991 static VLC mb_non_intra_vlc[4];
992 static VLC v2_dc_lum_vlc;
993 static VLC v2_dc_chroma_vlc;
995 static VLC v2_intra_cbpc_vlc;
996 static VLC v2_mb_type_vlc;
997 static VLC v2_mv_vlc;
998 static VLC v1_intra_cbpc_vlc;
999 static VLC v1_inter_cbpc_vlc;
1000 static VLC inter_intra_vlc;
1002 /* This table is practically identical to the one from h263
1003 * except that it is inverted. */
1004 static void init_h263_dc_for_msmpeg4(void)
1006 int level, uni_code, uni_len;
1008 for(level=-256; level<256; level++){
1010 /* find number of bits */
1019 l= (-level) ^ ((1 << size) - 1);
1023 /* luminance h263 */
1024 uni_code= DCtab_lum[size][0];
1025 uni_len = DCtab_lum[size][1];
1026 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1029 uni_code<<=size; uni_code|=l;
1032 uni_code<<=1; uni_code|=1;
1036 v2_dc_lum_table[level+256][0]= uni_code;
1037 v2_dc_lum_table[level+256][1]= uni_len;
1039 /* chrominance h263 */
1040 uni_code= DCtab_chrom[size][0];
1041 uni_len = DCtab_chrom[size][1];
1042 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1045 uni_code<<=size; uni_code|=l;
1048 uni_code<<=1; uni_code|=1;
1052 v2_dc_chroma_table[level+256][0]= uni_code;
1053 v2_dc_chroma_table[level+256][1]= uni_len;
1058 /* init all vlc decoding tables */
1059 int ff_msmpeg4_decode_init(MpegEncContext *s)
1061 static int done = 0;
1070 for(i=0;i<NB_RL_TABLES;i++) {
1071 init_rl(&rl_table[i], static_rl_table_store[i]);
1072 init_vlc_rl(&rl_table[i], 1);
1076 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1077 mv->table_mv_bits, 1, 1,
1078 mv->table_mv_code, 2, 2, 1);
1081 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1082 &ff_table0_dc_lum[0][1], 8, 4,
1083 &ff_table0_dc_lum[0][0], 8, 4, 1);
1084 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1085 &ff_table0_dc_chroma[0][1], 8, 4,
1086 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1087 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1088 &ff_table1_dc_lum[0][1], 8, 4,
1089 &ff_table1_dc_lum[0][0], 8, 4, 1);
1090 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1091 &ff_table1_dc_chroma[0][1], 8, 4,
1092 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1094 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1095 &v2_dc_lum_table[0][1], 8, 4,
1096 &v2_dc_lum_table[0][0], 8, 4, 1);
1097 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1098 &v2_dc_chroma_table[0][1], 8, 4,
1099 &v2_dc_chroma_table[0][0], 8, 4, 1);
1101 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1102 &cbpy_tab[0][1], 2, 1,
1103 &cbpy_tab[0][0], 2, 1, 1);
1104 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1105 &v2_intra_cbpc[0][1], 2, 1,
1106 &v2_intra_cbpc[0][0], 2, 1, 1);
1107 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1108 &v2_mb_type[0][1], 2, 1,
1109 &v2_mb_type[0][0], 2, 1, 1);
1110 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1112 &mvtab[0][0], 2, 1, 1);
1115 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1116 &wmv2_inter_table[i][0][1], 8, 4,
1117 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1120 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1121 &ff_msmp4_mb_i_table[0][1], 4, 2,
1122 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1124 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1125 intra_MCBPC_bits, 1, 1,
1126 intra_MCBPC_code, 1, 1, 1);
1127 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1128 inter_MCBPC_bits, 1, 1,
1129 inter_MCBPC_code, 1, 1, 1);
1131 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1132 &table_inter_intra[0][1], 2, 1,
1133 &table_inter_intra[0][0], 2, 1, 1);
1136 switch(s->msmpeg4_version){
1139 s->decode_mb= msmpeg4v12_decode_mb;
1143 s->decode_mb= msmpeg4v34_decode_mb;
1146 s->decode_mb= wmv2_decode_mb;
1148 //FIXME + TODO VC1 decode mb
1152 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1157 int msmpeg4_decode_picture_header(MpegEncContext * s)
1164 for(i=0; i<s->gb.size_in_bits; i++)
1165 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1166 // get_bits1(&s->gb);
1167 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1172 if(s->msmpeg4_version==1){
1173 int start_code, num;
1174 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1175 if(start_code!=0x00000100){
1176 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1180 num= get_bits(&s->gb, 5); // frame number */
1183 s->pict_type = get_bits(&s->gb, 2) + 1;
1184 if (s->pict_type != I_TYPE &&
1185 s->pict_type != P_TYPE){
1186 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1192 if(s->pict_type == I_TYPE) had_i=1;
1193 if(!had_i) return -1;
1196 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1198 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1202 if (s->pict_type == I_TYPE) {
1203 code = get_bits(&s->gb, 5);
1204 if(s->msmpeg4_version==1){
1205 if(code==0 || code>s->mb_height){
1206 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1210 s->slice_height = code;
1212 /* 0x17: one slice, 0x18: two slices, ... */
1214 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1218 s->slice_height = s->mb_height / (code - 0x16);
1221 switch(s->msmpeg4_version){
1224 s->rl_chroma_table_index = 2;
1225 s->rl_table_index = 2;
1227 s->dc_table_index = 0; //not used
1230 s->rl_chroma_table_index = decode012(&s->gb);
1231 s->rl_table_index = decode012(&s->gb);
1233 s->dc_table_index = get_bits1(&s->gb);
1236 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1238 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1239 else s->per_mb_rl_table= 0;
1241 if(!s->per_mb_rl_table){
1242 s->rl_chroma_table_index = decode012(&s->gb);
1243 s->rl_table_index = decode012(&s->gb);
1246 s->dc_table_index = get_bits1(&s->gb);
1247 s->inter_intra_pred= 0;
1251 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1252 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1254 s->rl_chroma_table_index,
1260 switch(s->msmpeg4_version){
1263 if(s->msmpeg4_version==1)
1264 s->use_skip_mb_code = 1;
1266 s->use_skip_mb_code = get_bits1(&s->gb);
1267 s->rl_table_index = 2;
1268 s->rl_chroma_table_index = s->rl_table_index;
1269 s->dc_table_index = 0; //not used
1270 s->mv_table_index = 0;
1273 s->use_skip_mb_code = get_bits1(&s->gb);
1274 s->rl_table_index = decode012(&s->gb);
1275 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);
1282 s->use_skip_mb_code = get_bits1(&s->gb);
1284 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1285 else s->per_mb_rl_table= 0;
1287 if(!s->per_mb_rl_table){
1288 s->rl_table_index = decode012(&s->gb);
1289 s->rl_chroma_table_index = s->rl_table_index;
1292 s->dc_table_index = get_bits1(&s->gb);
1294 s->mv_table_index = get_bits1(&s->gb);
1295 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1299 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1300 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1301 s->use_skip_mb_code,
1303 s->rl_chroma_table_index,
1309 if(s->flipflop_rounding){
1310 s->no_rounding ^= 1;
1315 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1317 s->esc3_level_length= 0;
1318 s->esc3_run_length= 0;
1321 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1326 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1328 int left= buf_size*8 - get_bits_count(&s->gb);
1329 int length= s->msmpeg4_version>=3 ? 17 : 16;
1330 /* the alt_bitstream reader could read over the end so we need to check it */
1331 if(left>=length && left<length+8)
1335 fps= get_bits(&s->gb, 5);
1336 s->bit_rate= get_bits(&s->gb, 11)*1024;
1337 if(s->msmpeg4_version>=3)
1338 s->flipflop_rounding= get_bits1(&s->gb);
1340 s->flipflop_rounding= 0;
1342 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1344 else if(left<length+8)
1346 s->flipflop_rounding= 0;
1347 if(s->msmpeg4_version != 2)
1348 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1352 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1358 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1365 #ifdef CONFIG_ENCODERS
1366 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1368 int range, bit_size, sign, code, bits;
1373 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1375 bit_size = s->f_code - 1;
1376 range = 1 << bit_size;
1389 code = (val >> bit_size) + 1;
1390 bits = val & (range - 1);
1392 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1394 put_bits(&s->pb, bit_size, bits);
1400 /* This is identical to h263 except that its range is multiplied by 2. */
1401 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1403 int code, val, sign, shift;
1405 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1406 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1412 sign = get_bits1(&s->gb);
1416 val = (val - 1) << shift;
1417 val |= get_bits(&s->gb, shift);
1432 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1436 if (s->pict_type == P_TYPE) {
1437 if (s->use_skip_mb_code) {
1438 if (get_bits1(&s->gb)) {
1442 s->block_last_index[i] = -1;
1443 s->mv_dir = MV_DIR_FORWARD;
1444 s->mv_type = MV_TYPE_16X16;
1452 if(s->msmpeg4_version==2)
1453 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1455 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1456 if(code<0 || code>7){
1457 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1461 s->mb_intra = code >>2;
1466 if(s->msmpeg4_version==2)
1467 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1469 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1471 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1479 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1481 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1486 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1488 h263_pred_motion(s, 0, 0, &mx, &my);
1489 mx= msmpeg4v2_decode_motion(s, mx, 1);
1490 my= msmpeg4v2_decode_motion(s, my, 1);
1492 s->mv_dir = MV_DIR_FORWARD;
1493 s->mv_type = MV_TYPE_16X16;
1494 s->mv[0][0][0] = mx;
1495 s->mv[0][0][1] = my;
1497 if(s->msmpeg4_version==2){
1498 s->ac_pred = get_bits1(&s->gb);
1499 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1502 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1503 if(s->pict_type==P_TYPE) cbp^=0x3C;
1507 s->dsp.clear_blocks(s->block[0]);
1508 for (i = 0; i < 6; i++) {
1509 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1511 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1518 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1522 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1524 if (s->pict_type == P_TYPE) {
1525 if (s->use_skip_mb_code) {
1526 if (get_bits1(&s->gb)) {
1530 s->block_last_index[i] = -1;
1531 s->mv_dir = MV_DIR_FORWARD;
1532 s->mv_type = MV_TYPE_16X16;
1536 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1542 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1545 //s->mb_intra = (code & 0x40) ? 0 : 1;
1546 s->mb_intra = (~code & 0x40) >> 6;
1551 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1554 /* predict coded block pattern */
1557 int val = ((code >> (5 - i)) & 1);
1559 int pred = coded_block_pred(s, i, &coded_val);
1563 cbp |= val << (5 - i);
1569 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1570 if(s->per_mb_rl_table && cbp){
1571 s->rl_table_index = decode012(&s->gb);
1572 s->rl_chroma_table_index = s->rl_table_index;
1574 h263_pred_motion(s, 0, 0, &mx, &my);
1575 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1577 s->mv_dir = MV_DIR_FORWARD;
1578 s->mv_type = MV_TYPE_16X16;
1579 s->mv[0][0][0] = mx;
1580 s->mv[0][0][1] = my;
1581 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1583 //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));
1584 s->ac_pred = get_bits1(&s->gb);
1585 *mb_type_ptr = MB_TYPE_INTRA;
1586 if(s->inter_intra_pred){
1587 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1588 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1590 if(s->per_mb_rl_table && cbp){
1591 s->rl_table_index = decode012(&s->gb);
1592 s->rl_chroma_table_index = s->rl_table_index;
1596 s->dsp.clear_blocks(s->block[0]);
1597 for (i = 0; i < 6; i++) {
1598 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1600 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1607 //#define ERROR_DETAILS
1608 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1609 int n, int coded, const uint8_t *scan_table)
1611 int level, i, last, run, run_diff;
1614 RL_VLC_ELEM *rl_vlc;
1622 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1625 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1626 if(s->inter_intra_pred) level=0;
1630 rl = &rl_table[s->rl_table_index];
1631 if(level > 256*s->y_dc_scale){
1632 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1633 if(!s->inter_intra_pred) return -1;
1636 rl = &rl_table[3 + s->rl_chroma_table_index];
1637 if(level > 256*s->c_dc_scale){
1638 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1639 if(!s->inter_intra_pred) return -1;
1650 if (dc_pred_dir == 0)
1651 scan_table = s->intra_v_scantable.permutated; /* left */
1653 scan_table = s->intra_h_scantable.permutated; /* top */
1655 scan_table = s->intra_scantable.permutated;
1657 rl_vlc= rl->rl_vlc[0];
1659 qmul = s->qscale << 1;
1660 qadd = (s->qscale - 1) | 1;
1662 rl = &rl_table[3 + s->rl_table_index];
1664 if(s->msmpeg4_version==2)
1670 s->block_last_index[n] = i;
1674 scan_table = s->inter_scantable.permutated;
1675 rl_vlc= rl->rl_vlc[s->qscale];
1678 OPEN_READER(re, &s->gb);
1680 UPDATE_CACHE(re, &s->gb);
1681 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1684 cache= GET_CACHE(re, &s->gb);
1686 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1687 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1689 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1690 UPDATE_CACHE(re, &s->gb);
1691 if(s->msmpeg4_version<=3){
1692 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1693 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1694 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1695 SKIP_COUNTER(re, &s->gb, 1+6+8);
1698 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1699 if(!s->esc3_level_length){
1701 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1703 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1705 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");
1706 SKIP_BITS(re, &s->gb, 1);
1711 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1713 SKIP_BITS(re, &s->gb, 1);
1715 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1718 s->esc3_level_length= ll;
1719 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1720 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1721 UPDATE_CACHE(re, &s->gb);
1723 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1724 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1726 sign= SHOW_UBITS(re, &s->gb, 1);
1727 SKIP_BITS(re, &s->gb, 1);
1729 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1730 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1731 if(sign) level= -level;
1733 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1734 #if 0 // waste of time / this will detect very few errors
1736 const int abs_level= FFABS(level);
1737 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1738 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1739 if(abs_level <= rl->max_level[last][run]){
1740 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1741 return DECODING_AC_LOST;
1743 if(abs_level <= rl->max_level[last][run]*2){
1744 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1745 return DECODING_AC_LOST;
1747 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1748 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1749 return DECODING_AC_LOST;
1754 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1755 if (level>0) level= level * qmul + qadd;
1756 else level= level * qmul - qadd;
1757 #if 0 // waste of time too :(
1758 if(level>2048 || level<-2048){
1759 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1760 return DECODING_AC_LOST;
1765 #ifdef ERROR_DETAILS
1767 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1768 else if((i>62 && i<192) || i>192+63)
1769 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1773 #if MIN_CACHE_BITS < 23
1774 LAST_SKIP_BITS(re, &s->gb, 2);
1775 UPDATE_CACHE(re, &s->gb);
1777 SKIP_BITS(re, &s->gb, 2);
1779 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1780 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1781 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1782 LAST_SKIP_BITS(re, &s->gb, 1);
1783 #ifdef ERROR_DETAILS
1785 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1786 else if((i>62 && i<192) || i>192+63)
1787 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1792 #if MIN_CACHE_BITS < 22
1793 LAST_SKIP_BITS(re, &s->gb, 1);
1794 UPDATE_CACHE(re, &s->gb);
1796 SKIP_BITS(re, &s->gb, 1);
1798 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1800 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1801 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1802 LAST_SKIP_BITS(re, &s->gb, 1);
1803 #ifdef ERROR_DETAILS
1805 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1806 else if((i>62 && i<192) || i>192+63)
1807 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1812 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1813 LAST_SKIP_BITS(re, &s->gb, 1);
1814 #ifdef ERROR_DETAILS
1816 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1817 else if((i>62 && i<192) || i>192+63)
1818 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1824 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1825 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1826 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1829 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1834 block[scan_table[i]] = level;
1838 block[scan_table[i]] = level;
1840 CLOSE_READER(re, &s->gb);
1844 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1846 i = 63; /* XXX: not optimal */
1849 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1850 s->block_last_index[n] = i;
1855 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1859 if(s->msmpeg4_version<=2){
1861 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1863 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1868 }else{ //FIXME optimize use unified tables & index
1870 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1872 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1875 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1879 if (level == DC_MAX) {
1880 level = get_bits(&s->gb, 8);
1881 if (get_bits1(&s->gb))
1883 } else if (level != 0) {
1884 if (get_bits1(&s->gb))
1889 if(s->msmpeg4_version==1){
1891 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1894 /* update predictor */
1898 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1901 /* update predictor */
1903 *dc_val = level * s->y_dc_scale;
1905 *dc_val = level * s->c_dc_scale;
1912 static int msmpeg4_decode_motion(MpegEncContext * s,
1913 int *mx_ptr, int *my_ptr)
1918 mv = &mv_tables[s->mv_table_index];
1920 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1922 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1925 if (code == mv->n) {
1926 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1927 mx = get_bits(&s->gb, 6);
1928 my = get_bits(&s->gb, 6);
1930 mx = mv->table_mvx[code];
1931 my = mv->table_mvy[code];
1936 /* WARNING : they do not do exactly modulo encoding */
1951 /* cleanest way to support it
1952 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1953 * as allmost everything would be in the common file