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
26 * @file libavcodec/msmpeg4.c
27 * MSMPEG4 backend for ffmpeg encoder and decoder.
32 #include "mpegvideo.h"
36 * You can also call this codec : MPEG4 with a twist !
39 * - (encoding) select best mv table (two choices)
40 * - (encoding) select best vlc/dc table
45 #define CBPY_VLC_BITS 6
46 #define V1_INTRA_CBPC_VLC_BITS 6
47 #define V1_INTER_CBPC_VLC_BITS 6
48 #define V2_INTRA_CBPC_VLC_BITS 3
49 #define V2_MB_TYPE_VLC_BITS 7
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
54 #define II_BITRATE 128*1024
55 #define MBAC_BITRATE 50*1024
57 #define DEFAULT_INTER_INDEX 3
59 static uint32_t v2_dc_lum_table[512][2];
60 static uint32_t v2_dc_chroma_table[512][2];
62 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
63 static void init_h263_dc_for_msmpeg4(void);
64 static inline void msmpeg4_memsetw(short *tab, int val, int n);
66 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
67 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
68 #endif //CONFIG_ENCODERS
69 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
70 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
73 extern const uint8_t wmv3_dc_scale_table[32];
80 #include "msmpeg4data.h"
82 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
83 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
84 #endif //CONFIG_ENCODERS
86 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
88 static av_cold void common_init(MpegEncContext * s)
90 static int initialized=0;
92 switch(s->msmpeg4_version){
96 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
99 if(s->workaround_bugs){
100 s->y_dc_scale_table= old_ff_y_dc_scale_table;
101 s->c_dc_scale_table= wmv1_c_dc_scale_table;
103 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
104 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
109 s->y_dc_scale_table= wmv1_y_dc_scale_table;
110 s->c_dc_scale_table= wmv1_c_dc_scale_table;
112 #if CONFIG_WMV3_DECODER || CONFIG_VC1_DECODER
114 s->y_dc_scale_table= wmv3_dc_scale_table;
115 s->c_dc_scale_table= wmv3_dc_scale_table;
122 if(s->msmpeg4_version>=4){
123 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]);
124 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
125 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
126 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]);
128 //Note the default tables are set in common_init in mpegvideo.c
133 init_h263_dc_for_msmpeg4();
139 /* build the table which associate a (x,y) motion vector to a vlc */
140 static void init_mv_table(MVTable *tab)
144 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
145 /* mark all entries as not used */
147 tab->table_mv_index[i] = tab->n;
149 for(i=0;i<tab->n;i++) {
150 x = tab->table_mvx[i];
151 y = tab->table_mvy[i];
152 tab->table_mv_index[(x << 6) | y] = i;
156 void ff_msmpeg4_code012(PutBitContext *pb, int n)
162 put_bits(pb, 1, (n >= 2));
166 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
168 static int init_done=0;
172 if(s->msmpeg4_version>=4){
178 /* init various encoding tables */
180 init_mv_table(&mv_tables[0]);
181 init_mv_table(&mv_tables[1]);
182 for(i=0;i<NB_RL_TABLES;i++)
183 init_rl(&rl_table[i], static_rl_table_store[i]);
185 for(i=0; i<NB_RL_TABLES; i++){
187 for(level=0; level<=MAX_LEVEL; level++){
189 for(run=0; run<=MAX_RUN; run++){
191 for(last=0; last<2; last++){
192 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);
200 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
203 int run_diff= intra ? 0 : 1;
205 code = get_rl_index(rl, last, run, level);
206 size+= rl->table_vlc[code][1];
210 level1 = level - rl->max_level[last][run];
213 code = get_rl_index(rl, last, run, level1);
217 if (level > MAX_LEVEL)
219 run1 = run - rl->max_run[last][level] - run_diff;
222 code = get_rl_index(rl, last, run1, level);
229 size+= 1+1+ rl->table_vlc[code][1];
233 size+= 1+1+ rl->table_vlc[code][1];
241 static void find_best_tables(MpegEncContext * s)
244 int best =-1, best_size =9999999;
245 int chroma_best=-1, best_chroma_size=9999999;
256 for(level=0; level<=MAX_LEVEL; level++){
258 for(run=0; run<=MAX_RUN; run++){
260 const int last_size= size + chroma_size;
261 for(last=0; last<2; last++){
262 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
263 int intra_luma_count = s->ac_stats[1][0][level][run][last];
264 int intra_chroma_count= s->ac_stats[1][1][level][run][last];
266 if(s->pict_type==FF_I_TYPE){
267 size += intra_luma_count *rl_length[i ][level][run][last];
268 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
270 size+= intra_luma_count *rl_length[i ][level][run][last]
271 +intra_chroma_count*rl_length[i+3][level][run][last]
272 +inter_count *rl_length[i+3][level][run][last];
275 if(last_size == size+chroma_size) break;
282 if(chroma_size<best_chroma_size){
283 best_chroma_size= chroma_size;
288 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
289 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
291 if(s->pict_type==FF_P_TYPE) chroma_best= best;
293 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
295 s->rl_table_index = best;
296 s->rl_chroma_table_index= chroma_best;
298 if(s->pict_type != s->last_non_b_pict_type){
299 s->rl_table_index= 2;
300 if(s->pict_type==FF_I_TYPE)
301 s->rl_chroma_table_index= 1;
303 s->rl_chroma_table_index= 2;
308 /* write MSMPEG4 compatible frame header */
309 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
313 align_put_bits(&s->pb);
314 put_bits(&s->pb, 2, s->pict_type - 1);
316 put_bits(&s->pb, 5, s->qscale);
317 if(s->msmpeg4_version<=2){
318 s->rl_table_index = 2;
319 s->rl_chroma_table_index = 2;
322 s->dc_table_index = 1;
323 s->mv_table_index = 1; /* only if P frame */
324 s->use_skip_mb_code = 1; /* only if P frame */
325 s->per_mb_rl_table = 0;
326 if(s->msmpeg4_version==4)
327 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
328 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
330 if (s->pict_type == FF_I_TYPE) {
331 s->slice_height= s->mb_height/1;
332 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
334 if(s->msmpeg4_version==4){
335 msmpeg4_encode_ext_header(s);
336 if(s->bit_rate>MBAC_BITRATE)
337 put_bits(&s->pb, 1, s->per_mb_rl_table);
340 if(s->msmpeg4_version>2){
341 if(!s->per_mb_rl_table){
342 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
343 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
346 put_bits(&s->pb, 1, s->dc_table_index);
349 put_bits(&s->pb, 1, s->use_skip_mb_code);
351 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
352 put_bits(&s->pb, 1, s->per_mb_rl_table);
354 if(s->msmpeg4_version>2){
355 if(!s->per_mb_rl_table)
356 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
358 put_bits(&s->pb, 1, s->dc_table_index);
360 put_bits(&s->pb, 1, s->mv_table_index);
364 s->esc3_level_length= 0;
365 s->esc3_run_length= 0;
369 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
373 void msmpeg4_encode_ext_header(MpegEncContext * s)
375 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
377 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
379 if(s->msmpeg4_version>=3)
380 put_bits(&s->pb, 1, s->flipflop_rounding);
382 assert(s->flipflop_rounding==0);
385 #endif //CONFIG_ENCODERS
387 /* predict coded block */
388 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
390 int xy, wrap, pred, a, b, c;
392 xy = s->block_index[n];
398 a = s->coded_block[xy - 1 ];
399 b = s->coded_block[xy - 1 - wrap];
400 c = s->coded_block[xy - wrap];
409 *coded_block_ptr = &s->coded_block[xy];
416 void ff_msmpeg4_encode_motion(MpegEncContext * s,
422 /* modulo encoding */
423 /* WARNING : you cannot reach all the MVs even with the modulo
424 encoding. This is a somewhat strange compromise they took !!! */
437 if ((unsigned)mx >= 64 ||
439 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
441 mv = &mv_tables[s->mv_table_index];
443 code = mv->table_mv_index[(mx << 6) | my];
445 mv->table_mv_bits[code],
446 mv->table_mv_code[code]);
448 /* escape : code literally */
449 put_bits(&s->pb, 6, mx);
450 put_bits(&s->pb, 6, my);
454 void ff_msmpeg4_handle_slices(MpegEncContext *s){
456 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
457 if(s->msmpeg4_version < 4){
458 ff_mpeg4_clean_buffers(s);
460 s->first_slice_line = 1;
462 s->first_slice_line = 0;
467 void msmpeg4_encode_mb(MpegEncContext * s,
468 DCTELEM block[6][64],
469 int motion_x, int motion_y)
471 int cbp, coded_cbp, i;
473 uint8_t *coded_block;
475 ff_msmpeg4_handle_slices(s);
480 for (i = 0; i < 6; i++) {
481 if (s->block_last_index[i] >= 0)
484 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
485 /* skip macroblock */
486 put_bits(&s->pb, 1, 1);
493 if (s->use_skip_mb_code)
494 put_bits(&s->pb, 1, 0); /* mb coded */
496 if(s->msmpeg4_version<=2){
498 v2_mb_type[cbp&3][1],
499 v2_mb_type[cbp&3][0]);
500 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
504 cbpy_tab[coded_cbp>>2][1],
505 cbpy_tab[coded_cbp>>2][0]);
507 s->misc_bits += get_bits_diff(s);
509 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
510 msmpeg4v2_encode_motion(s, motion_x - pred_x);
511 msmpeg4v2_encode_motion(s, motion_y - pred_y);
514 table_mb_non_intra[cbp + 64][1],
515 table_mb_non_intra[cbp + 64][0]);
517 s->misc_bits += get_bits_diff(s);
520 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
521 ff_msmpeg4_encode_motion(s, motion_x - pred_x,
525 s->mv_bits += get_bits_diff(s);
527 for (i = 0; i < 6; i++) {
528 ff_msmpeg4_encode_block(s, block[i], i);
530 s->p_tex_bits += get_bits_diff(s);
535 for (i = 0; i < 6; i++) {
537 val = (s->block_last_index[i] >= 1);
538 cbp |= val << (5 - i);
540 /* predict value for close blocks only for luma */
541 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
545 coded_cbp |= val << (5 - i);
549 printf("cbp=%x %x\n", cbp, coded_cbp);
552 if(s->msmpeg4_version<=2){
553 if (s->pict_type == FF_I_TYPE) {
555 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
557 if (s->use_skip_mb_code)
558 put_bits(&s->pb, 1, 0); /* mb coded */
560 v2_mb_type[(cbp&3) + 4][1],
561 v2_mb_type[(cbp&3) + 4][0]);
563 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
566 cbpy_tab[cbp>>2][0]);
568 if (s->pict_type == FF_I_TYPE) {
570 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
572 if (s->use_skip_mb_code)
573 put_bits(&s->pb, 1, 0); /* mb coded */
575 table_mb_non_intra[cbp][1],
576 table_mb_non_intra[cbp][0]);
578 put_bits(&s->pb, 1, 0); /* no AC prediction yet */
579 if(s->inter_intra_pred){
581 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
584 s->misc_bits += get_bits_diff(s);
586 for (i = 0; i < 6; i++) {
587 ff_msmpeg4_encode_block(s, block[i], i);
589 s->i_tex_bits += get_bits_diff(s);
594 #endif //CONFIG_ENCODERS
596 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
597 int32_t **dc_val_ptr)
607 *dc_val_ptr= &s->last_dc[i];
608 return s->last_dc[i];
611 static int get_dc(uint8_t *src, int stride, int scale)
618 sum+=src[x + y*stride];
621 return FASTDIV((sum + (scale>>1)), scale);
624 /* dir = 0: left, dir = 1: top prediction */
625 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
626 int16_t **dc_val_ptr, int *dir_ptr)
628 int a, b, c, wrap, pred, scale;
631 /* find prediction */
633 scale = s->y_dc_scale;
635 scale = s->c_dc_scale;
638 wrap = s->block_wrap[n];
639 dc_val= s->dc_val[0] + s->block_index[n];
645 b = dc_val[ - 1 - wrap];
648 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
652 /* XXX: the following solution consumes divisions, but it does not
653 necessitate to modify mpegvideo.c. The problem comes from the
654 fact they decided to store the quantized DC (which would lead
655 to problems if Q could vary !) */
656 #if ARCH_X86 && !defined PIC
658 "movl %3, %%eax \n\t"
659 "shrl $1, %%eax \n\t"
660 "addl %%eax, %2 \n\t"
661 "addl %%eax, %1 \n\t"
662 "addl %0, %%eax \n\t"
664 "movl %%edx, %0 \n\t"
665 "movl %1, %%eax \n\t"
667 "movl %%edx, %1 \n\t"
668 "movl %2, %%eax \n\t"
670 "movl %%edx, %2 \n\t"
671 : "+b" (a), "+c" (b), "+D" (c)
672 : "g" (scale), "S" (ff_inverse[scale])
676 /* #elif ARCH_ALPHA */
677 /* Divisions are extremely costly on Alpha; optimize the most
678 common case. But they are costly everywhere...
681 a = (a + (8 >> 1)) / 8;
682 b = (b + (8 >> 1)) / 8;
683 c = (c + (8 >> 1)) / 8;
685 a = FASTDIV((a + (scale >> 1)), scale);
686 b = FASTDIV((b + (scale >> 1)), scale);
687 c = FASTDIV((c + (scale >> 1)), scale);
690 /* XXX: WARNING: they did not choose the same test as MPEG4. This
691 is very important ! */
692 if(s->msmpeg4_version>3){
693 if(s->inter_intra_pred){
704 if (abs(a - b) < abs(b - c)) {
714 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8;
717 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
719 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
720 else a= get_dc(dest-8, wrap, scale*8);
721 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
722 else c= get_dc(dest-8*wrap, wrap, scale*8);
724 if (s->h263_aic_dir==0) {
727 }else if (s->h263_aic_dir==1) {
735 }else if (s->h263_aic_dir==2) {
749 if (abs(a - b) < abs(b - c)) {
758 if (abs(a - b) <= abs(b - c)) {
767 /* update predictor */
768 *dc_val_ptr = &dc_val[0];
774 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
780 if(s->msmpeg4_version==1){
782 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
784 /* update predictor */
788 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
790 /* update predictor */
792 *dc_val = level * s->y_dc_scale;
794 *dc_val = level * s->c_dc_scale;
798 /* do the prediction */
801 if(s->msmpeg4_version<=2){
804 v2_dc_lum_table[level+256][1],
805 v2_dc_lum_table[level+256][0]);
808 v2_dc_chroma_table[level+256][1],
809 v2_dc_chroma_table[level+256][0]);
820 else if( s->msmpeg4_version>=6 ) {
821 if( s->qscale == 1 ) {
822 extquant = (level + 3) & 0x3;
823 code = ((level+3)>>2);
824 } else if( s->qscale == 2 ) {
825 extquant = (level + 1) & 0x1;
826 code = ((level+1)>>1);
830 if (s->dc_table_index == 0) {
832 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
834 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
838 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
840 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
844 if(s->msmpeg4_version>=6 && s->qscale<=2)
845 extrabits = 3 - s->qscale;
848 put_bits(&s->pb, 8 + extrabits, level);
849 else if(extrabits > 0)//== VC1 && s->qscale<=2
850 put_bits(&s->pb, extrabits, extquant);
853 put_bits(&s->pb, 1, sign);
858 /* Encoding of a block. Very similar to MPEG4 except for a different
859 escape coding (same as H263) and more vlc tables.
861 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
863 int level, run, last, i, j, last_index;
864 int last_non_zero, sign, slevel;
865 int code, run_diff, dc_pred_dir;
867 const uint8_t *scantable;
870 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
873 rl = &rl_table[s->rl_table_index];
875 rl = &rl_table[3 + s->rl_chroma_table_index];
877 run_diff = s->msmpeg4_version>=4;
878 scantable= s->intra_scantable.permutated;
881 rl = &rl_table[3 + s->rl_table_index];
882 if(s->msmpeg4_version<=2)
886 scantable= s->inter_scantable.permutated;
889 /* recalculate block_last_index for M$ wmv1 */
890 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
891 for(last_index=63; last_index>=0; last_index--){
892 if(block[scantable[last_index]]) break;
894 s->block_last_index[n]= last_index;
896 last_index = s->block_last_index[n];
898 last_non_zero = i - 1;
899 for (; i <= last_index; i++) {
903 run = i - last_non_zero - 1;
904 last = (i == last_index);
912 if(level<=MAX_LEVEL && run<=MAX_RUN){
913 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
917 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
919 code = get_rl_index(rl, last, run, level);
920 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
924 level1 = level - rl->max_level[last][run];
927 code = get_rl_index(rl, last, run, level1);
930 put_bits(&s->pb, 1, 0);
931 if (level > MAX_LEVEL)
933 run1 = run - rl->max_run[last][level] - run_diff;
936 code = get_rl_index(rl, last, run1+1, level);
937 if (s->msmpeg4_version == 4 && code == rl->n)
939 code = get_rl_index(rl, last, run1, level);
943 put_bits(&s->pb, 1, 0);
944 put_bits(&s->pb, 1, last);
945 if(s->msmpeg4_version>=4){
946 if(s->esc3_level_length==0){
947 s->esc3_level_length=8;
948 s->esc3_run_length= 6;
949 //ESCLVLSZ + ESCRUNSZ
951 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
953 put_bits(&s->pb, 8, 3);
955 put_bits(&s->pb, s->esc3_run_length, run);
956 put_bits(&s->pb, 1, sign);
957 put_bits(&s->pb, s->esc3_level_length, level);
959 put_bits(&s->pb, 6, run);
960 put_sbits(&s->pb, 8, slevel);
964 put_bits(&s->pb, 1, 1);
965 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
966 put_bits(&s->pb, 1, sign);
970 put_bits(&s->pb, 1, 1);
971 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
972 put_bits(&s->pb, 1, sign);
975 put_bits(&s->pb, 1, sign);
982 /****************************************/
985 VLC ff_mb_non_intra_vlc[4];
986 static VLC v2_dc_lum_vlc;
987 static VLC v2_dc_chroma_vlc;
989 static VLC v2_intra_cbpc_vlc;
990 static VLC v2_mb_type_vlc;
991 static VLC v2_mv_vlc;
992 static VLC v1_intra_cbpc_vlc;
993 static VLC v1_inter_cbpc_vlc;
994 VLC ff_inter_intra_vlc;
996 /* This table is practically identical to the one from h263
997 * except that it is inverted. */
998 static av_cold void init_h263_dc_for_msmpeg4(void)
1000 int level, uni_code, uni_len;
1002 for(level=-256; level<256; level++){
1004 /* find number of bits */
1013 l= (-level) ^ ((1 << size) - 1);
1017 /* luminance h263 */
1018 uni_code= DCtab_lum[size][0];
1019 uni_len = DCtab_lum[size][1];
1020 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1023 uni_code<<=size; uni_code|=l;
1026 uni_code<<=1; uni_code|=1;
1030 v2_dc_lum_table[level+256][0]= uni_code;
1031 v2_dc_lum_table[level+256][1]= uni_len;
1033 /* chrominance h263 */
1034 uni_code= DCtab_chrom[size][0];
1035 uni_len = DCtab_chrom[size][1];
1036 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1039 uni_code<<=size; uni_code|=l;
1042 uni_code<<=1; uni_code|=1;
1046 v2_dc_chroma_table[level+256][0]= uni_code;
1047 v2_dc_chroma_table[level+256][1]= uni_len;
1052 /* init all vlc decoding tables */
1053 av_cold int ff_msmpeg4_decode_init(MpegEncContext *s)
1055 static int done = 0;
1064 for(i=0;i<NB_RL_TABLES;i++) {
1065 init_rl(&rl_table[i], static_rl_table_store[i]);
1067 INIT_VLC_RL(rl_table[0], 642);
1068 INIT_VLC_RL(rl_table[1], 1104);
1069 INIT_VLC_RL(rl_table[2], 554);
1070 INIT_VLC_RL(rl_table[3], 940);
1071 INIT_VLC_RL(rl_table[4], 962);
1072 INIT_VLC_RL(rl_table[5], 554);
1075 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1076 mv->table_mv_bits, 1, 1,
1077 mv->table_mv_code, 2, 2, 3714);
1079 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1080 mv->table_mv_bits, 1, 1,
1081 mv->table_mv_code, 2, 2, 2694);
1083 INIT_VLC_STATIC(&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, 1158);
1086 INIT_VLC_STATIC(&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, 1118);
1089 INIT_VLC_STATIC(&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, 1476);
1092 INIT_VLC_STATIC(&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, 1216);
1096 INIT_VLC_STATIC(&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, 1472);
1099 INIT_VLC_STATIC(&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, 1506);
1103 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
1104 &cbpy_tab[0][1], 2, 1,
1105 &cbpy_tab[0][0], 2, 1, 64);
1106 INIT_VLC_STATIC(&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, 8);
1109 INIT_VLC_STATIC(&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, 128);
1112 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1114 &mvtab[0][0], 2, 1, 538);
1116 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1117 &wmv2_inter_table[0][0][1], 8, 4,
1118 &wmv2_inter_table[0][0][0], 8, 4, 1636);
1119 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1120 &wmv2_inter_table[1][0][1], 8, 4,
1121 &wmv2_inter_table[1][0][0], 8, 4, 2648);
1122 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1123 &wmv2_inter_table[2][0][1], 8, 4,
1124 &wmv2_inter_table[2][0][0], 8, 4, 1532);
1125 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1126 &wmv2_inter_table[3][0][1], 8, 4,
1127 &wmv2_inter_table[3][0][0], 8, 4, 2488);
1129 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1130 &ff_msmp4_mb_i_table[0][1], 4, 2,
1131 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1133 INIT_VLC_STATIC(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1134 intra_MCBPC_bits, 1, 1,
1135 intra_MCBPC_code, 1, 1, 64);
1136 INIT_VLC_STATIC(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1137 inter_MCBPC_bits, 1, 1,
1138 inter_MCBPC_code, 1, 1, 104);
1140 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1141 &table_inter_intra[0][1], 2, 1,
1142 &table_inter_intra[0][0], 2, 1, 8);
1145 switch(s->msmpeg4_version){
1148 s->decode_mb= msmpeg4v12_decode_mb;
1152 s->decode_mb= msmpeg4v34_decode_mb;
1155 if (CONFIG_WMV2_DECODER)
1156 s->decode_mb= ff_wmv2_decode_mb;
1158 //FIXME + TODO VC1 decode mb
1162 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1167 int msmpeg4_decode_picture_header(MpegEncContext * s)
1174 for(i=0; i<s->gb.size_in_bits; i++)
1175 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1176 // get_bits1(&s->gb);
1177 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1182 if(s->msmpeg4_version==1){
1183 int start_code, num;
1184 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1185 if(start_code!=0x00000100){
1186 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1190 num= get_bits(&s->gb, 5); // frame number */
1193 s->pict_type = get_bits(&s->gb, 2) + 1;
1194 if (s->pict_type != FF_I_TYPE &&
1195 s->pict_type != FF_P_TYPE){
1196 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1202 if(s->pict_type == FF_I_TYPE) had_i=1;
1203 if(!had_i) return -1;
1206 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1208 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1212 if (s->pict_type == FF_I_TYPE) {
1213 code = get_bits(&s->gb, 5);
1214 if(s->msmpeg4_version==1){
1215 if(code==0 || code>s->mb_height){
1216 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1220 s->slice_height = code;
1222 /* 0x17: one slice, 0x18: two slices, ... */
1224 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1228 s->slice_height = s->mb_height / (code - 0x16);
1231 switch(s->msmpeg4_version){
1234 s->rl_chroma_table_index = 2;
1235 s->rl_table_index = 2;
1237 s->dc_table_index = 0; //not used
1240 s->rl_chroma_table_index = decode012(&s->gb);
1241 s->rl_table_index = decode012(&s->gb);
1243 s->dc_table_index = get_bits1(&s->gb);
1246 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1248 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1249 else s->per_mb_rl_table= 0;
1251 if(!s->per_mb_rl_table){
1252 s->rl_chroma_table_index = decode012(&s->gb);
1253 s->rl_table_index = decode012(&s->gb);
1256 s->dc_table_index = get_bits1(&s->gb);
1257 s->inter_intra_pred= 0;
1261 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1262 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
1264 s->rl_chroma_table_index,
1270 switch(s->msmpeg4_version){
1273 if(s->msmpeg4_version==1)
1274 s->use_skip_mb_code = 1;
1276 s->use_skip_mb_code = get_bits1(&s->gb);
1277 s->rl_table_index = 2;
1278 s->rl_chroma_table_index = s->rl_table_index;
1279 s->dc_table_index = 0; //not used
1280 s->mv_table_index = 0;
1283 s->use_skip_mb_code = get_bits1(&s->gb);
1284 s->rl_table_index = decode012(&s->gb);
1285 s->rl_chroma_table_index = s->rl_table_index;
1287 s->dc_table_index = get_bits1(&s->gb);
1289 s->mv_table_index = get_bits1(&s->gb);
1292 s->use_skip_mb_code = get_bits1(&s->gb);
1294 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1295 else s->per_mb_rl_table= 0;
1297 if(!s->per_mb_rl_table){
1298 s->rl_table_index = decode012(&s->gb);
1299 s->rl_chroma_table_index = s->rl_table_index;
1302 s->dc_table_index = get_bits1(&s->gb);
1304 s->mv_table_index = get_bits1(&s->gb);
1305 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1309 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1310 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
1311 s->use_skip_mb_code,
1313 s->rl_chroma_table_index,
1319 if(s->flipflop_rounding){
1320 s->no_rounding ^= 1;
1325 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1327 s->esc3_level_length= 0;
1328 s->esc3_run_length= 0;
1331 av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1336 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1338 int left= buf_size*8 - get_bits_count(&s->gb);
1339 int length= s->msmpeg4_version>=3 ? 17 : 16;
1340 /* the alt_bitstream reader could read over the end so we need to check it */
1341 if(left>=length && left<length+8)
1345 fps= get_bits(&s->gb, 5);
1346 s->bit_rate= get_bits(&s->gb, 11)*1024;
1347 if(s->msmpeg4_version>=3)
1348 s->flipflop_rounding= get_bits1(&s->gb);
1350 s->flipflop_rounding= 0;
1352 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1354 else if(left<length+8)
1356 s->flipflop_rounding= 0;
1357 if(s->msmpeg4_version != 2)
1358 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1362 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1368 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1376 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1378 int range, bit_size, sign, code, bits;
1383 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1385 bit_size = s->f_code - 1;
1386 range = 1 << bit_size;
1399 code = (val >> bit_size) + 1;
1400 bits = val & (range - 1);
1402 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1404 put_bits(&s->pb, bit_size, bits);
1410 /* This is identical to h263 except that its range is multiplied by 2. */
1411 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1413 int code, val, sign, shift;
1415 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1416 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1422 sign = get_bits1(&s->gb);
1426 val = (val - 1) << shift;
1427 val |= get_bits(&s->gb, shift);
1442 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1446 if (s->pict_type == FF_P_TYPE) {
1447 if (s->use_skip_mb_code) {
1448 if (get_bits1(&s->gb)) {
1452 s->block_last_index[i] = -1;
1453 s->mv_dir = MV_DIR_FORWARD;
1454 s->mv_type = MV_TYPE_16X16;
1462 if(s->msmpeg4_version==2)
1463 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1465 code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1466 if(code<0 || code>7){
1467 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1471 s->mb_intra = code >>2;
1476 if(s->msmpeg4_version==2)
1477 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1479 cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1481 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1489 cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1491 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1496 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1498 h263_pred_motion(s, 0, 0, &mx, &my);
1499 mx= msmpeg4v2_decode_motion(s, mx, 1);
1500 my= msmpeg4v2_decode_motion(s, my, 1);
1502 s->mv_dir = MV_DIR_FORWARD;
1503 s->mv_type = MV_TYPE_16X16;
1504 s->mv[0][0][0] = mx;
1505 s->mv[0][0][1] = my;
1507 if(s->msmpeg4_version==2){
1508 s->ac_pred = get_bits1(&s->gb);
1509 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1512 cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1513 if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1517 s->dsp.clear_blocks(s->block[0]);
1518 for (i = 0; i < 6; i++) {
1519 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1521 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1528 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1532 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1534 if (s->pict_type == FF_P_TYPE) {
1535 if (s->use_skip_mb_code) {
1536 if (get_bits1(&s->gb)) {
1540 s->block_last_index[i] = -1;
1541 s->mv_dir = MV_DIR_FORWARD;
1542 s->mv_type = MV_TYPE_16X16;
1546 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1552 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1555 //s->mb_intra = (code & 0x40) ? 0 : 1;
1556 s->mb_intra = (~code & 0x40) >> 6;
1561 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1564 /* predict coded block pattern */
1567 int val = ((code >> (5 - i)) & 1);
1569 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1573 cbp |= val << (5 - i);
1579 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1580 if(s->per_mb_rl_table && cbp){
1581 s->rl_table_index = decode012(&s->gb);
1582 s->rl_chroma_table_index = s->rl_table_index;
1584 h263_pred_motion(s, 0, 0, &mx, &my);
1585 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1587 s->mv_dir = MV_DIR_FORWARD;
1588 s->mv_type = MV_TYPE_16X16;
1589 s->mv[0][0][0] = mx;
1590 s->mv[0][0][1] = my;
1591 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1593 //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));
1594 s->ac_pred = get_bits1(&s->gb);
1595 *mb_type_ptr = MB_TYPE_INTRA;
1596 if(s->inter_intra_pred){
1597 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1598 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1600 if(s->per_mb_rl_table && cbp){
1601 s->rl_table_index = decode012(&s->gb);
1602 s->rl_chroma_table_index = s->rl_table_index;
1606 s->dsp.clear_blocks(s->block[0]);
1607 for (i = 0; i < 6; i++) {
1608 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1610 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1617 //#define ERROR_DETAILS
1618 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1619 int n, int coded, const uint8_t *scan_table)
1621 int level, i, last, run, run_diff;
1622 int av_uninit(dc_pred_dir);
1624 RL_VLC_ELEM *rl_vlc;
1632 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1635 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1636 if(s->inter_intra_pred) level=0;
1640 rl = &rl_table[s->rl_table_index];
1641 if(level > 256*s->y_dc_scale){
1642 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1643 if(!s->inter_intra_pred) return -1;
1646 rl = &rl_table[3 + s->rl_chroma_table_index];
1647 if(level > 256*s->c_dc_scale){
1648 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1649 if(!s->inter_intra_pred) return -1;
1654 run_diff = s->msmpeg4_version >= 4;
1660 if (dc_pred_dir == 0)
1661 scan_table = s->intra_v_scantable.permutated; /* left */
1663 scan_table = s->intra_h_scantable.permutated; /* top */
1665 scan_table = s->intra_scantable.permutated;
1667 rl_vlc= rl->rl_vlc[0];
1669 qmul = s->qscale << 1;
1670 qadd = (s->qscale - 1) | 1;
1672 rl = &rl_table[3 + s->rl_table_index];
1674 if(s->msmpeg4_version==2)
1680 s->block_last_index[n] = i;
1684 scan_table = s->inter_scantable.permutated;
1685 rl_vlc= rl->rl_vlc[s->qscale];
1688 OPEN_READER(re, &s->gb);
1690 UPDATE_CACHE(re, &s->gb);
1691 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1694 cache= GET_CACHE(re, &s->gb);
1696 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1697 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1699 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1700 UPDATE_CACHE(re, &s->gb);
1701 if(s->msmpeg4_version<=3){
1702 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1703 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1704 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1705 SKIP_COUNTER(re, &s->gb, 1+6+8);
1708 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1709 if(!s->esc3_level_length){
1711 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1713 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1715 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");
1716 SKIP_BITS(re, &s->gb, 1);
1721 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1723 SKIP_BITS(re, &s->gb, 1);
1725 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1728 s->esc3_level_length= ll;
1729 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1730 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1731 UPDATE_CACHE(re, &s->gb);
1733 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1734 SKIP_BITS(re, &s->gb, s->esc3_run_length);
1736 sign= SHOW_UBITS(re, &s->gb, 1);
1737 SKIP_BITS(re, &s->gb, 1);
1739 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1740 SKIP_BITS(re, &s->gb, s->esc3_level_length);
1741 if(sign) level= -level;
1743 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1744 #if 0 // waste of time / this will detect very few errors
1746 const int abs_level= FFABS(level);
1747 const int run1= run - rl->max_run[last][abs_level] - run_diff;
1748 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1749 if(abs_level <= rl->max_level[last][run]){
1750 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1751 return DECODING_AC_LOST;
1753 if(abs_level <= rl->max_level[last][run]*2){
1754 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1755 return DECODING_AC_LOST;
1757 if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1758 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1759 return DECODING_AC_LOST;
1764 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1765 if (level>0) level= level * qmul + qadd;
1766 else level= level * qmul - qadd;
1767 #if 0 // waste of time too :(
1768 if(level>2048 || level<-2048){
1769 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1770 return DECODING_AC_LOST;
1775 #ifdef ERROR_DETAILS
1777 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1778 else if((i>62 && i<192) || i>192+63)
1779 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1783 #if MIN_CACHE_BITS < 23
1784 LAST_SKIP_BITS(re, &s->gb, 2);
1785 UPDATE_CACHE(re, &s->gb);
1787 SKIP_BITS(re, &s->gb, 2);
1789 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1790 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1791 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1792 LAST_SKIP_BITS(re, &s->gb, 1);
1793 #ifdef ERROR_DETAILS
1795 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1796 else if((i>62 && i<192) || i>192+63)
1797 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1802 #if MIN_CACHE_BITS < 22
1803 LAST_SKIP_BITS(re, &s->gb, 1);
1804 UPDATE_CACHE(re, &s->gb);
1806 SKIP_BITS(re, &s->gb, 1);
1808 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1810 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1811 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1812 LAST_SKIP_BITS(re, &s->gb, 1);
1813 #ifdef ERROR_DETAILS
1815 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1816 else if((i>62 && i<192) || i>192+63)
1817 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1822 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1823 LAST_SKIP_BITS(re, &s->gb, 1);
1824 #ifdef ERROR_DETAILS
1826 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1827 else if((i>62 && i<192) || i>192+63)
1828 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1834 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1835 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1836 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1839 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1844 block[scan_table[i]] = level;
1848 block[scan_table[i]] = level;
1850 CLOSE_READER(re, &s->gb);
1854 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1856 i = 63; /* XXX: not optimal */
1859 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1860 s->block_last_index[n] = i;
1865 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1869 if(s->msmpeg4_version<=2){
1871 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1873 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1878 }else{ //FIXME optimize use unified tables & index
1880 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1882 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1885 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1889 if (level == DC_MAX) {
1890 level = get_bits(&s->gb, 8);
1891 if (get_bits1(&s->gb))
1893 } else if (level != 0) {
1894 if (get_bits1(&s->gb))
1899 if(s->msmpeg4_version==1){
1901 pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1904 /* update predictor */
1908 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1911 /* update predictor */
1913 *dc_val = level * s->y_dc_scale;
1915 *dc_val = level * s->c_dc_scale;
1922 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1923 int *mx_ptr, int *my_ptr)
1928 mv = &mv_tables[s->mv_table_index];
1930 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1932 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1935 if (code == mv->n) {
1936 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1937 mx = get_bits(&s->gb, 6);
1938 my = get_bits(&s->gb, 6);
1940 mx = mv->table_mvx[code];
1941 my = mv->table_mvy[code];
1946 /* WARNING : they do not do exactly modulo encoding */