2 * MSMPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
27 * MSMPEG4 backend for ffmpeg encoder and decoder.
32 #include "mpegvideo.h"
35 * You can also call this codec : MPEG4 with a twist !
38 * - (encoding) select best mv table (two choices)
39 * - (encoding) select best vlc/dc table
44 #define CBPY_VLC_BITS 6
45 #define INTER_INTRA_VLC_BITS 3
46 #define V1_INTRA_CBPC_VLC_BITS 6
47 #define V1_INTER_CBPC_VLC_BITS 6
48 #define V2_INTRA_CBPC_VLC_BITS 3
49 #define V2_MB_TYPE_VLC_BITS 7
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
53 #define MB_NON_INTRA_VLC_BITS 9
54 #define MB_INTRA_VLC_BITS 9
56 #define II_BITRATE 128*1024
57 #define MBAC_BITRATE 50*1024
59 #define DEFAULT_INTER_INDEX 3
61 static uint32_t v2_dc_lum_table[512][2];
62 static uint32_t v2_dc_chroma_table[512][2];
64 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
65 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
66 int n, int coded, const uint8_t *scantable);
67 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
68 static int msmpeg4_decode_motion(MpegEncContext * s,
69 int *mx_ptr, int *my_ptr);
70 static void init_h263_dc_for_msmpeg4(void);
71 static inline void msmpeg4_memsetw(short *tab, int val, int n);
72 #ifdef CONFIG_ENCODERS
73 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
74 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
75 #endif //CONFIG_ENCODERS
76 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
77 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
78 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
81 extern uint8_t wmv3_dc_scale_table[32];
88 #include "msmpeg4data.h"
89 #include "msmpeg4tab.h"
91 #ifdef CONFIG_ENCODERS //strangely gcc includes this even if its 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 static void 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)
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 litterally */
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 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 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)
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]);
829 if (s->dc_table_index == 0) {
831 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
833 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
837 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
839 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
844 put_bits(&s->pb, 8, level);
847 put_bits(&s->pb, 1, sign);
852 /* Encoding of a block. Very similar to MPEG4 except for a different
853 escape coding (same as H263) and more vlc tables.
855 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
857 int level, run, last, i, j, last_index;
858 int last_non_zero, sign, slevel;
859 int code, run_diff, dc_pred_dir;
861 const uint8_t *scantable;
864 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
867 rl = &rl_table[s->rl_table_index];
869 rl = &rl_table[3 + s->rl_chroma_table_index];
872 scantable= s->intra_scantable.permutated;
875 rl = &rl_table[3 + s->rl_table_index];
876 if(s->msmpeg4_version<=2)
880 scantable= s->inter_scantable.permutated;
883 /* recalculate block_last_index for M$ wmv1 */
884 if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
885 for(last_index=63; last_index>=0; last_index--){
886 if(block[scantable[last_index]]) break;
888 s->block_last_index[n]= last_index;
890 last_index = s->block_last_index[n];
892 last_non_zero = i - 1;
893 for (; i <= last_index; i++) {
897 run = i - last_non_zero - 1;
898 last = (i == last_index);
906 if(level<=MAX_LEVEL && run<=MAX_RUN){
907 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
911 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
913 code = get_rl_index(rl, last, run, level);
914 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
918 level1 = level - rl->max_level[last][run];
921 code = get_rl_index(rl, last, run, level1);
924 put_bits(&s->pb, 1, 0);
925 if (level > MAX_LEVEL)
927 run1 = run - rl->max_run[last][level] - run_diff;
930 code = get_rl_index(rl, last, run1, level);
934 put_bits(&s->pb, 1, 0);
935 put_bits(&s->pb, 1, last);
936 if(s->msmpeg4_version>=4){
937 if(s->esc3_level_length==0){
938 s->esc3_level_length=8;
939 s->esc3_run_length= 6;
941 put_bits(&s->pb, 6, 3);
943 put_bits(&s->pb, 8, 3);
945 put_bits(&s->pb, s->esc3_run_length, run);
946 put_bits(&s->pb, 1, sign);
947 put_bits(&s->pb, s->esc3_level_length, level);
949 put_bits(&s->pb, 6, run);
950 put_bits(&s->pb, 8, slevel & 0xff);
954 put_bits(&s->pb, 1, 1);
955 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
956 put_bits(&s->pb, 1, sign);
960 put_bits(&s->pb, 1, 1);
961 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
962 put_bits(&s->pb, 1, sign);
965 put_bits(&s->pb, 1, sign);
972 /****************************************/
975 static VLC mb_non_intra_vlc[4];
976 static VLC v2_dc_lum_vlc;
977 static VLC v2_dc_chroma_vlc;
979 static VLC v2_intra_cbpc_vlc;
980 static VLC v2_mb_type_vlc;
981 static VLC v2_mv_vlc;
982 static VLC v1_intra_cbpc_vlc;
983 static VLC v1_inter_cbpc_vlc;
984 static VLC inter_intra_vlc;
986 /* this table is practically identical to the one from h263 except that its inverted */
987 static void init_h263_dc_for_msmpeg4(void)
989 int level, uni_code, uni_len;
991 for(level=-256; level<256; level++){
993 /* find number of bits */
1002 l= (-level) ^ ((1 << size) - 1);
1006 /* luminance h263 */
1007 uni_code= DCtab_lum[size][0];
1008 uni_len = DCtab_lum[size][1];
1009 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1012 uni_code<<=size; uni_code|=l;
1015 uni_code<<=1; uni_code|=1;
1019 v2_dc_lum_table[level+256][0]= uni_code;
1020 v2_dc_lum_table[level+256][1]= uni_len;
1022 /* chrominance h263 */
1023 uni_code= DCtab_chrom[size][0];
1024 uni_len = DCtab_chrom[size][1];
1025 uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1028 uni_code<<=size; uni_code|=l;
1031 uni_code<<=1; uni_code|=1;
1035 v2_dc_chroma_table[level+256][0]= uni_code;
1036 v2_dc_chroma_table[level+256][1]= uni_len;
1041 /* init all vlc decoding tables */
1042 int ff_msmpeg4_decode_init(MpegEncContext *s)
1044 static int done = 0;
1053 for(i=0;i<NB_RL_TABLES;i++) {
1054 init_rl(&rl_table[i], static_rl_table_store[i]);
1055 init_vlc_rl(&rl_table[i], 1);
1059 init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1060 mv->table_mv_bits, 1, 1,
1061 mv->table_mv_code, 2, 2, 1);
1064 init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1065 &ff_table0_dc_lum[0][1], 8, 4,
1066 &ff_table0_dc_lum[0][0], 8, 4, 1);
1067 init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1068 &ff_table0_dc_chroma[0][1], 8, 4,
1069 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1070 init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1071 &ff_table1_dc_lum[0][1], 8, 4,
1072 &ff_table1_dc_lum[0][0], 8, 4, 1);
1073 init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1074 &ff_table1_dc_chroma[0][1], 8, 4,
1075 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1077 init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1078 &v2_dc_lum_table[0][1], 8, 4,
1079 &v2_dc_lum_table[0][0], 8, 4, 1);
1080 init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1081 &v2_dc_chroma_table[0][1], 8, 4,
1082 &v2_dc_chroma_table[0][0], 8, 4, 1);
1084 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1085 &cbpy_tab[0][1], 2, 1,
1086 &cbpy_tab[0][0], 2, 1, 1);
1087 init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1088 &v2_intra_cbpc[0][1], 2, 1,
1089 &v2_intra_cbpc[0][0], 2, 1, 1);
1090 init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1091 &v2_mb_type[0][1], 2, 1,
1092 &v2_mb_type[0][0], 2, 1, 1);
1093 init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1095 &mvtab[0][0], 2, 1, 1);
1098 init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1099 &wmv2_inter_table[i][0][1], 8, 4,
1100 &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1103 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1104 &ff_msmp4_mb_i_table[0][1], 4, 2,
1105 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1107 init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1108 intra_MCBPC_bits, 1, 1,
1109 intra_MCBPC_code, 1, 1, 1);
1110 init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1111 inter_MCBPC_bits, 1, 1,
1112 inter_MCBPC_code, 1, 1, 1);
1114 init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1115 &table_inter_intra[0][1], 2, 1,
1116 &table_inter_intra[0][0], 2, 1, 1);
1119 switch(s->msmpeg4_version){
1122 s->decode_mb= msmpeg4v12_decode_mb;
1126 s->decode_mb= msmpeg4v34_decode_mb;
1129 s->decode_mb= wmv2_decode_mb;
1131 //FIXME + TODO VC1 decode mb
1135 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1140 int msmpeg4_decode_picture_header(MpegEncContext * s)
1147 for(i=0; i<s->gb.size_in_bits; i++)
1148 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1149 // get_bits1(&s->gb);
1150 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1155 if(s->msmpeg4_version==1){
1156 int start_code, num;
1157 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1158 if(start_code!=0x00000100){
1159 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1163 num= get_bits(&s->gb, 5); // frame number */
1166 s->pict_type = get_bits(&s->gb, 2) + 1;
1167 if (s->pict_type != I_TYPE &&
1168 s->pict_type != P_TYPE){
1169 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1175 if(s->pict_type == I_TYPE) had_i=1;
1176 if(!had_i) return -1;
1179 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1181 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1185 if (s->pict_type == I_TYPE) {
1186 code = get_bits(&s->gb, 5);
1187 if(s->msmpeg4_version==1){
1188 if(code==0 || code>s->mb_height){
1189 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1193 s->slice_height = code;
1195 /* 0x17: one slice, 0x18: two slices, ... */
1197 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1201 s->slice_height = s->mb_height / (code - 0x16);
1204 switch(s->msmpeg4_version){
1207 s->rl_chroma_table_index = 2;
1208 s->rl_table_index = 2;
1210 s->dc_table_index = 0; //not used
1213 s->rl_chroma_table_index = decode012(&s->gb);
1214 s->rl_table_index = decode012(&s->gb);
1216 s->dc_table_index = get_bits1(&s->gb);
1219 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1221 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1222 else s->per_mb_rl_table= 0;
1224 if(!s->per_mb_rl_table){
1225 s->rl_chroma_table_index = decode012(&s->gb);
1226 s->rl_table_index = decode012(&s->gb);
1229 s->dc_table_index = get_bits1(&s->gb);
1230 s->inter_intra_pred= 0;
1234 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1235 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1237 s->rl_chroma_table_index,
1243 switch(s->msmpeg4_version){
1246 if(s->msmpeg4_version==1)
1247 s->use_skip_mb_code = 1;
1249 s->use_skip_mb_code = get_bits1(&s->gb);
1250 s->rl_table_index = 2;
1251 s->rl_chroma_table_index = s->rl_table_index;
1252 s->dc_table_index = 0; //not used
1253 s->mv_table_index = 0;
1256 s->use_skip_mb_code = get_bits1(&s->gb);
1257 s->rl_table_index = decode012(&s->gb);
1258 s->rl_chroma_table_index = s->rl_table_index;
1260 s->dc_table_index = get_bits1(&s->gb);
1262 s->mv_table_index = get_bits1(&s->gb);
1265 s->use_skip_mb_code = get_bits1(&s->gb);
1267 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1268 else s->per_mb_rl_table= 0;
1270 if(!s->per_mb_rl_table){
1271 s->rl_table_index = decode012(&s->gb);
1272 s->rl_chroma_table_index = s->rl_table_index;
1275 s->dc_table_index = get_bits1(&s->gb);
1277 s->mv_table_index = get_bits1(&s->gb);
1278 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1282 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1283 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1284 s->use_skip_mb_code,
1286 s->rl_chroma_table_index,
1292 if(s->flipflop_rounding){
1293 s->no_rounding ^= 1;
1298 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1300 s->esc3_level_length= 0;
1301 s->esc3_run_length= 0;
1304 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1309 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1311 int left= buf_size*8 - get_bits_count(&s->gb);
1312 int length= s->msmpeg4_version>=3 ? 17 : 16;
1313 /* the alt_bitstream reader could read over the end so we need to check it */
1314 if(left>=length && left<length+8)
1318 fps= get_bits(&s->gb, 5);
1319 s->bit_rate= get_bits(&s->gb, 11)*1024;
1320 if(s->msmpeg4_version>=3)
1321 s->flipflop_rounding= get_bits1(&s->gb);
1323 s->flipflop_rounding= 0;
1325 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1327 else if(left<length+8)
1329 s->flipflop_rounding= 0;
1330 if(s->msmpeg4_version != 2)
1331 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1335 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1341 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1348 #ifdef CONFIG_ENCODERS
1349 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1351 int range, bit_size, sign, code, bits;
1356 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1358 bit_size = s->f_code - 1;
1359 range = 1 << bit_size;
1372 code = (val >> bit_size) + 1;
1373 bits = val & (range - 1);
1375 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1377 put_bits(&s->pb, bit_size, bits);
1383 /* this is identical to h263 except that its range is multiplied by 2 */
1384 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1386 int code, val, sign, shift;
1388 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1389 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1395 sign = get_bits1(&s->gb);
1399 val = (val - 1) << shift;
1400 val |= get_bits(&s->gb, shift);
1415 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1419 if (s->pict_type == P_TYPE) {
1420 if (s->use_skip_mb_code) {
1421 if (get_bits1(&s->gb)) {
1425 s->block_last_index[i] = -1;
1426 s->mv_dir = MV_DIR_FORWARD;
1427 s->mv_type = MV_TYPE_16X16;
1435 if(s->msmpeg4_version==2)
1436 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1438 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1439 if(code<0 || code>7){
1440 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1444 s->mb_intra = code >>2;
1449 if(s->msmpeg4_version==2)
1450 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1452 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1454 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1462 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1464 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1469 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1471 h263_pred_motion(s, 0, 0, &mx, &my);
1472 mx= msmpeg4v2_decode_motion(s, mx, 1);
1473 my= msmpeg4v2_decode_motion(s, my, 1);
1475 s->mv_dir = MV_DIR_FORWARD;
1476 s->mv_type = MV_TYPE_16X16;
1477 s->mv[0][0][0] = mx;
1478 s->mv[0][0][1] = my;
1480 if(s->msmpeg4_version==2){
1481 s->ac_pred = get_bits1(&s->gb);
1482 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1485 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1486 if(s->pict_type==P_TYPE) cbp^=0x3C;
1490 s->dsp.clear_blocks(s->block[0]);
1491 for (i = 0; i < 6; i++) {
1492 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1494 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1501 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1505 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1507 if (s->pict_type == P_TYPE) {
1508 if (s->use_skip_mb_code) {
1509 if (get_bits1(&s->gb)) {
1513 s->block_last_index[i] = -1;
1514 s->mv_dir = MV_DIR_FORWARD;
1515 s->mv_type = MV_TYPE_16X16;
1519 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1525 code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1528 //s->mb_intra = (code & 0x40) ? 0 : 1;
1529 s->mb_intra = (~code & 0x40) >> 6;
1534 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1537 /* predict coded block pattern */
1540 int val = ((code >> (5 - i)) & 1);
1542 int pred = coded_block_pred(s, i, &coded_val);
1546 cbp |= val << (5 - i);
1552 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1553 if(s->per_mb_rl_table && cbp){
1554 s->rl_table_index = decode012(&s->gb);
1555 s->rl_chroma_table_index = s->rl_table_index;
1557 h263_pred_motion(s, 0, 0, &mx, &my);
1558 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1560 s->mv_dir = MV_DIR_FORWARD;
1561 s->mv_type = MV_TYPE_16X16;
1562 s->mv[0][0][0] = mx;
1563 s->mv[0][0][1] = my;
1564 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1566 //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));
1567 s->ac_pred = get_bits1(&s->gb);
1568 *mb_type_ptr = MB_TYPE_INTRA;
1569 if(s->inter_intra_pred){
1570 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1571 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1573 if(s->per_mb_rl_table && cbp){
1574 s->rl_table_index = decode012(&s->gb);
1575 s->rl_chroma_table_index = s->rl_table_index;
1579 s->dsp.clear_blocks(s->block[0]);
1580 for (i = 0; i < 6; i++) {
1581 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1583 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1590 //#define ERROR_DETAILS
1591 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1592 int n, int coded, const uint8_t *scan_table)
1594 int level, i, last, run, run_diff;
1597 RL_VLC_ELEM *rl_vlc;
1605 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1608 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1609 if(s->inter_intra_pred) level=0;
1613 rl = &rl_table[s->rl_table_index];
1614 if(level > 256*s->y_dc_scale){
1615 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1616 if(!s->inter_intra_pred) return -1;
1619 rl = &rl_table[3 + s->rl_chroma_table_index];
1620 if(level > 256*s->c_dc_scale){
1621 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1622 if(!s->inter_intra_pred) return -1;
1633 if (dc_pred_dir == 0)
1634 scan_table = s->intra_v_scantable.permutated; /* left */
1636 scan_table = s->intra_h_scantable.permutated; /* top */
1638 scan_table = s->intra_scantable.permutated;
1640 rl_vlc= rl->rl_vlc[0];
1642 qmul = s->qscale << 1;
1643 qadd = (s->qscale - 1) | 1;
1645 rl = &rl_table[3 + s->rl_table_index];
1647 if(s->msmpeg4_version==2)
1653 s->block_last_index[n] = i;
1657 scan_table = s->inter_scantable.permutated;
1658 rl_vlc= rl->rl_vlc[s->qscale];
1661 OPEN_READER(re, &s->gb);
1663 UPDATE_CACHE(re, &s->gb);
1664 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1667 cache= GET_CACHE(re, &s->gb);
1669 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1670 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1672 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1673 UPDATE_CACHE(re, &s->gb);
1674 if(s->msmpeg4_version<=3){
1675 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1676 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1677 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1678 SKIP_COUNTER(re, &s->gb, 1+6+8);
1681 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1682 if(!s->esc3_level_length){
1684 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1686 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1688 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");
1689 SKIP_BITS(re, &s->gb, 1);
1694 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1696 SKIP_BITS(re, &s->gb, 1);
1698 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1701 s->esc3_level_length= ll;
1702 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1703 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1704 UPDATE_CACHE(re, &s->gb);
1706 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1707 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1709 sign= SHOW_UBITS(re, &s->gb, 1);
1710 SKIP_BITS(re, &s->gb, 1);
1712 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1713 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1714 if(sign) level= -level;
1716 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1717 #if 0 // waste of time / this will detect very few errors
1719 const int abs_level= FFABS(level);
1720 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1721 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1722 if(abs_level <= rl->max_level[last][run]){
1723 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1724 return DECODING_AC_LOST;
1726 if(abs_level <= rl->max_level[last][run]*2){
1727 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1728 return DECODING_AC_LOST;
1730 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1731 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1732 return DECODING_AC_LOST;
1737 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1738 if (level>0) level= level * qmul + qadd;
1739 else level= level * qmul - qadd;
1740 #if 0 // waste of time too :(
1741 if(level>2048 || level<-2048){
1742 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1743 return DECODING_AC_LOST;
1748 #ifdef ERROR_DETAILS
1750 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1751 else if((i>62 && i<192) || i>192+63)
1752 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1756 #if MIN_CACHE_BITS < 23
1757 LAST_SKIP_BITS(re, &s->gb, 2);
1758 UPDATE_CACHE(re, &s->gb);
1760 SKIP_BITS(re, &s->gb, 2);
1762 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1763 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1764 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1765 LAST_SKIP_BITS(re, &s->gb, 1);
1766 #ifdef ERROR_DETAILS
1768 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1769 else if((i>62 && i<192) || i>192+63)
1770 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1775 #if MIN_CACHE_BITS < 22
1776 LAST_SKIP_BITS(re, &s->gb, 1);
1777 UPDATE_CACHE(re, &s->gb);
1779 SKIP_BITS(re, &s->gb, 1);
1781 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1783 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1784 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1785 LAST_SKIP_BITS(re, &s->gb, 1);
1786 #ifdef ERROR_DETAILS
1788 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1789 else if((i>62 && i<192) || i>192+63)
1790 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1795 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1796 LAST_SKIP_BITS(re, &s->gb, 1);
1797 #ifdef ERROR_DETAILS
1799 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1800 else if((i>62 && i<192) || i>192+63)
1801 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1807 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1808 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1809 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1812 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1817 block[scan_table[i]] = level;
1821 block[scan_table[i]] = level;
1823 CLOSE_READER(re, &s->gb);
1827 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1829 i = 63; /* XXX: not optimal */
1832 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1833 s->block_last_index[n] = i;
1838 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1842 if(s->msmpeg4_version<=2){
1844 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1846 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1851 }else{ //FIXME optimize use unified tables & index
1853 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1855 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1858 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1862 if (level == DC_MAX) {
1863 level = get_bits(&s->gb, 8);
1864 if (get_bits1(&s->gb))
1866 } else if (level != 0) {
1867 if (get_bits1(&s->gb))
1872 if(s->msmpeg4_version==1){
1874 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1877 /* update predictor */
1881 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1884 /* update predictor */
1886 *dc_val = level * s->y_dc_scale;
1888 *dc_val = level * s->c_dc_scale;
1895 static int msmpeg4_decode_motion(MpegEncContext * s,
1896 int *mx_ptr, int *my_ptr)
1901 mv = &mv_tables[s->mv_table_index];
1903 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1905 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1908 if (code == mv->n) {
1909 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1910 mx = get_bits(&s->gb, 6);
1911 my = get_bits(&s->gb, 6);
1913 mx = mv->table_mvx[code];
1914 my = mv->table_mvy[code];
1919 /* WARNING : they do not do exactly modulo encoding */
1934 /* cleanest way to support it
1935 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1936 * as allmost everything would be in the common file