Remove unused variable intra_count.
[ffmpeg.git] / libavcodec / msmpeg4.c
1 /*
2  * MSMPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
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.
14  *
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.
19  *
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
23  */
24
25 /**
26  * @file libavcodec/msmpeg4.c
27  * MSMPEG4 backend for ffmpeg encoder and decoder.
28  */
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33 #include "msmpeg4.h"
34
35 /*
36  * You can also call this codec : MPEG4 with a twist !
37  *
38  * TODO:
39  *        - (encoding) select best mv table (two choices)
40  *        - (encoding) select best vlc/dc table
41  */
42 //#define DEBUG
43
44 #define DC_VLC_BITS 9
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
50 #define MV_VLC_BITS 9
51 #define V2_MV_VLC_BITS 9
52 #define TEX_VLC_BITS 9
53
54 #define II_BITRATE 128*1024
55 #define MBAC_BITRATE 50*1024
56
57 #define DEFAULT_INTER_INDEX 3
58
59 static uint32_t v2_dc_lum_table[512][2];
60 static uint32_t v2_dc_chroma_table[512][2];
61
62 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
63 static void init_h263_dc_for_msmpeg4(void);
64 static inline void msmpeg4_memsetw(short *tab, int val, int n);
65 #if CONFIG_ENCODERS
66 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
67 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
68 #endif //CONFIG_ENCODERS
69 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
70 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
71
72 /* vc1 externs */
73 extern const uint8_t wmv3_dc_scale_table[32];
74
75 #ifdef DEBUG
76 int frame_count = 0;
77 #endif
78
79 #include "msmpeg4data.h"
80
81 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
82 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
83 #endif //CONFIG_ENCODERS
84
85 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
86
87 static av_cold void common_init(MpegEncContext * s)
88 {
89     static int initialized=0;
90
91     switch(s->msmpeg4_version){
92     case 1:
93     case 2:
94         s->y_dc_scale_table=
95         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
96         break;
97     case 3:
98         if(s->workaround_bugs){
99             s->y_dc_scale_table= old_ff_y_dc_scale_table;
100             s->c_dc_scale_table= wmv1_c_dc_scale_table;
101         } else{
102             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
103             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
104         }
105         break;
106     case 4:
107     case 5:
108         s->y_dc_scale_table= wmv1_y_dc_scale_table;
109         s->c_dc_scale_table= wmv1_c_dc_scale_table;
110         break;
111 #if CONFIG_VC1_DECODER
112     case 6:
113         s->y_dc_scale_table= wmv3_dc_scale_table;
114         s->c_dc_scale_table= wmv3_dc_scale_table;
115         break;
116 #endif
117
118     }
119
120
121     if(s->msmpeg4_version>=4){
122         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
123         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
124         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
125         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
126     }
127     //Note the default tables are set in common_init in mpegvideo.c
128
129     if(!initialized){
130         initialized=1;
131
132         init_h263_dc_for_msmpeg4();
133     }
134 }
135
136 #if CONFIG_ENCODERS
137
138 /* build the table which associate a (x,y) motion vector to a vlc */
139 static void init_mv_table(MVTable *tab)
140 {
141     int i, x, y;
142
143     tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
144     /* mark all entries as not used */
145     for(i=0;i<4096;i++)
146         tab->table_mv_index[i] = tab->n;
147
148     for(i=0;i<tab->n;i++) {
149         x = tab->table_mvx[i];
150         y = tab->table_mvy[i];
151         tab->table_mv_index[(x << 6) | y] = i;
152     }
153 }
154
155 void ff_msmpeg4_code012(PutBitContext *pb, int n)
156 {
157     if (n == 0) {
158         put_bits(pb, 1, 0);
159     } else {
160         put_bits(pb, 1, 1);
161         put_bits(pb, 1, (n >= 2));
162     }
163 }
164
165 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
166 {
167     static int init_done=0;
168     int i;
169
170     common_init(s);
171     if(s->msmpeg4_version>=4){
172         s->min_qcoeff= -255;
173         s->max_qcoeff=  255;
174     }
175
176     if (!init_done) {
177         /* init various encoding tables */
178         init_done = 1;
179         init_mv_table(&mv_tables[0]);
180         init_mv_table(&mv_tables[1]);
181         for(i=0;i<NB_RL_TABLES;i++)
182             init_rl(&rl_table[i], static_rl_table_store[i]);
183
184         for(i=0; i<NB_RL_TABLES; i++){
185             int level;
186             for(level=0; level<=MAX_LEVEL; level++){
187                 int run;
188                 for(run=0; run<=MAX_RUN; run++){
189                     int last;
190                     for(last=0; last<2; last++){
191                         rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
192                     }
193                 }
194             }
195         }
196     }
197 }
198
199 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
200     int size=0;
201     int code;
202     int run_diff= intra ? 0 : 1;
203
204     code = get_rl_index(rl, last, run, level);
205     size+= rl->table_vlc[code][1];
206     if (code == rl->n) {
207         int level1, run1;
208
209         level1 = level - rl->max_level[last][run];
210         if (level1 < 1)
211             goto esc2;
212         code = get_rl_index(rl, last, run, level1);
213         if (code == rl->n) {
214             esc2:
215             size++;
216             if (level > MAX_LEVEL)
217                 goto esc3;
218             run1 = run - rl->max_run[last][level] - run_diff;
219             if (run1 < 0)
220                 goto esc3;
221             code = get_rl_index(rl, last, run1, level);
222             if (code == rl->n) {
223             esc3:
224                 /* third escape */
225                 size+=1+1+6+8;
226             } else {
227                 /* second escape */
228                 size+= 1+1+ rl->table_vlc[code][1];
229             }
230         } else {
231             /* first escape */
232             size+= 1+1+ rl->table_vlc[code][1];
233         }
234     } else {
235         size++;
236     }
237     return size;
238 }
239
240 static void find_best_tables(MpegEncContext * s)
241 {
242     int i;
243     int best       =-1, best_size       =9999999;
244     int chroma_best=-1, best_chroma_size=9999999;
245
246     for(i=0; i<3; i++){
247         int level;
248         int chroma_size=0;
249         int size=0;
250
251         if(i>0){// ;)
252             size++;
253             chroma_size++;
254         }
255         for(level=0; level<=MAX_LEVEL; level++){
256             int run;
257             for(run=0; run<=MAX_RUN; run++){
258                 int last;
259                 const int last_size= size + chroma_size;
260                 for(last=0; last<2; last++){
261                     int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
262                     int intra_luma_count  = s->ac_stats[1][0][level][run][last];
263                     int intra_chroma_count= s->ac_stats[1][1][level][run][last];
264
265                     if(s->pict_type==FF_I_TYPE){
266                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
267                         chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
268                     }else{
269                         size+=        intra_luma_count  *rl_length[i  ][level][run][last]
270                                      +intra_chroma_count*rl_length[i+3][level][run][last]
271                                      +inter_count       *rl_length[i+3][level][run][last];
272                     }
273                 }
274                 if(last_size == size+chroma_size) break;
275             }
276         }
277         if(size<best_size){
278             best_size= size;
279             best= i;
280         }
281         if(chroma_size<best_chroma_size){
282             best_chroma_size= chroma_size;
283             chroma_best= i;
284         }
285     }
286
287 //    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
288 //           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
289
290     if(s->pict_type==FF_P_TYPE) chroma_best= best;
291
292     memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
293
294     s->rl_table_index       =        best;
295     s->rl_chroma_table_index= chroma_best;
296
297     if(s->pict_type != s->last_non_b_pict_type){
298         s->rl_table_index= 2;
299         if(s->pict_type==FF_I_TYPE)
300             s->rl_chroma_table_index= 1;
301         else
302             s->rl_chroma_table_index= 2;
303     }
304
305 }
306
307 /* write MSMPEG4 compatible frame header */
308 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
309 {
310     find_best_tables(s);
311
312     align_put_bits(&s->pb);
313     put_bits(&s->pb, 2, s->pict_type - 1);
314
315     put_bits(&s->pb, 5, s->qscale);
316     if(s->msmpeg4_version<=2){
317         s->rl_table_index = 2;
318         s->rl_chroma_table_index = 2;
319     }
320
321     s->dc_table_index = 1;
322     s->mv_table_index = 1; /* only if P frame */
323     s->use_skip_mb_code = 1; /* only if P frame */
324     s->per_mb_rl_table = 0;
325     if(s->msmpeg4_version==4)
326         s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
327 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
328
329     if (s->pict_type == FF_I_TYPE) {
330         s->slice_height= s->mb_height/1;
331         put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
332
333         if(s->msmpeg4_version==4){
334             msmpeg4_encode_ext_header(s);
335             if(s->bit_rate>MBAC_BITRATE)
336                 put_bits(&s->pb, 1, s->per_mb_rl_table);
337         }
338
339         if(s->msmpeg4_version>2){
340             if(!s->per_mb_rl_table){
341                 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
342                 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
343             }
344
345             put_bits(&s->pb, 1, s->dc_table_index);
346         }
347     } else {
348         put_bits(&s->pb, 1, s->use_skip_mb_code);
349
350         if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
351             put_bits(&s->pb, 1, s->per_mb_rl_table);
352
353         if(s->msmpeg4_version>2){
354             if(!s->per_mb_rl_table)
355                 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
356
357             put_bits(&s->pb, 1, s->dc_table_index);
358
359             put_bits(&s->pb, 1, s->mv_table_index);
360         }
361     }
362
363     s->esc3_level_length= 0;
364     s->esc3_run_length= 0;
365
366 #ifdef DEBUG
367     av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
368 #endif
369 }
370
371 void msmpeg4_encode_ext_header(MpegEncContext * s)
372 {
373         put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
374
375         put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
376
377         if(s->msmpeg4_version>=3)
378             put_bits(&s->pb, 1, s->flipflop_rounding);
379         else
380             assert(s->flipflop_rounding==0);
381 }
382
383 #endif //CONFIG_ENCODERS
384
385 /* predict coded block */
386 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
387 {
388     int xy, wrap, pred, a, b, c;
389
390     xy = s->block_index[n];
391     wrap = s->b8_stride;
392
393     /* B C
394      * A X
395      */
396     a = s->coded_block[xy - 1       ];
397     b = s->coded_block[xy - 1 - wrap];
398     c = s->coded_block[xy     - wrap];
399
400     if (b == c) {
401         pred = a;
402     } else {
403         pred = c;
404     }
405
406     /* store value */
407     *coded_block_ptr = &s->coded_block[xy];
408
409     return pred;
410 }
411
412 #if CONFIG_ENCODERS
413
414 void ff_msmpeg4_encode_motion(MpegEncContext * s,
415                                   int mx, int my)
416 {
417     int code;
418     MVTable *mv;
419
420     /* modulo encoding */
421     /* WARNING : you cannot reach all the MVs even with the modulo
422        encoding. This is a somewhat strange compromise they took !!!  */
423     if (mx <= -64)
424         mx += 64;
425     else if (mx >= 64)
426         mx -= 64;
427     if (my <= -64)
428         my += 64;
429     else if (my >= 64)
430         my -= 64;
431
432     mx += 32;
433     my += 32;
434 #if 0
435     if ((unsigned)mx >= 64 ||
436         (unsigned)my >= 64)
437         av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
438 #endif
439     mv = &mv_tables[s->mv_table_index];
440
441     code = mv->table_mv_index[(mx << 6) | my];
442     put_bits(&s->pb,
443              mv->table_mv_bits[code],
444              mv->table_mv_code[code]);
445     if (code == mv->n) {
446         /* escape : code literally */
447         put_bits(&s->pb, 6, mx);
448         put_bits(&s->pb, 6, my);
449     }
450 }
451
452 void ff_msmpeg4_handle_slices(MpegEncContext *s){
453     if (s->mb_x == 0) {
454         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
455             if(s->msmpeg4_version < 4){
456                 ff_mpeg4_clean_buffers(s);
457             }
458             s->first_slice_line = 1;
459         } else {
460             s->first_slice_line = 0;
461         }
462     }
463 }
464
465 void msmpeg4_encode_mb(MpegEncContext * s,
466                        DCTELEM block[6][64],
467                        int motion_x, int motion_y)
468 {
469     int cbp, coded_cbp, i;
470     int pred_x, pred_y;
471     uint8_t *coded_block;
472
473     ff_msmpeg4_handle_slices(s);
474
475     if (!s->mb_intra) {
476         /* compute cbp */
477         cbp = 0;
478         for (i = 0; i < 6; i++) {
479             if (s->block_last_index[i] >= 0)
480                 cbp |= 1 << (5 - i);
481         }
482         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
483             /* skip macroblock */
484             put_bits(&s->pb, 1, 1);
485             s->last_bits++;
486             s->misc_bits++;
487             s->skip_count++;
488
489             return;
490         }
491         if (s->use_skip_mb_code)
492             put_bits(&s->pb, 1, 0);     /* mb coded */
493
494         if(s->msmpeg4_version<=2){
495             put_bits(&s->pb,
496                      v2_mb_type[cbp&3][1],
497                      v2_mb_type[cbp&3][0]);
498             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
499             else             coded_cbp= cbp;
500
501             put_bits(&s->pb,
502                      cbpy_tab[coded_cbp>>2][1],
503                      cbpy_tab[coded_cbp>>2][0]);
504
505             s->misc_bits += get_bits_diff(s);
506
507             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
508             msmpeg4v2_encode_motion(s, motion_x - pred_x);
509             msmpeg4v2_encode_motion(s, motion_y - pred_y);
510         }else{
511             put_bits(&s->pb,
512                      table_mb_non_intra[cbp + 64][1],
513                      table_mb_non_intra[cbp + 64][0]);
514
515             s->misc_bits += get_bits_diff(s);
516
517             /* motion vector */
518             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
519             ff_msmpeg4_encode_motion(s, motion_x - pred_x,
520                                   motion_y - pred_y);
521         }
522
523         s->mv_bits += get_bits_diff(s);
524
525         for (i = 0; i < 6; i++) {
526             ff_msmpeg4_encode_block(s, block[i], i);
527         }
528         s->p_tex_bits += get_bits_diff(s);
529     } else {
530         /* compute cbp */
531         cbp = 0;
532         coded_cbp = 0;
533         for (i = 0; i < 6; i++) {
534             int val, pred;
535             val = (s->block_last_index[i] >= 1);
536             cbp |= val << (5 - i);
537             if (i < 4) {
538                 /* predict value for close blocks only for luma */
539                 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
540                 *coded_block = val;
541                 val = val ^ pred;
542             }
543             coded_cbp |= val << (5 - i);
544         }
545 #if 0
546         if (coded_cbp)
547             printf("cbp=%x %x\n", cbp, coded_cbp);
548 #endif
549
550         if(s->msmpeg4_version<=2){
551             if (s->pict_type == FF_I_TYPE) {
552                 put_bits(&s->pb,
553                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
554             } else {
555                 if (s->use_skip_mb_code)
556                     put_bits(&s->pb, 1, 0);     /* mb coded */
557                 put_bits(&s->pb,
558                          v2_mb_type[(cbp&3) + 4][1],
559                          v2_mb_type[(cbp&3) + 4][0]);
560             }
561             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
562             put_bits(&s->pb,
563                      cbpy_tab[cbp>>2][1],
564                      cbpy_tab[cbp>>2][0]);
565         }else{
566             if (s->pict_type == FF_I_TYPE) {
567                 put_bits(&s->pb,
568                          ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
569             } else {
570                 if (s->use_skip_mb_code)
571                     put_bits(&s->pb, 1, 0);     /* mb coded */
572                 put_bits(&s->pb,
573                          table_mb_non_intra[cbp][1],
574                          table_mb_non_intra[cbp][0]);
575             }
576             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
577             if(s->inter_intra_pred){
578                 s->h263_aic_dir=0;
579                 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
580             }
581         }
582         s->misc_bits += get_bits_diff(s);
583
584         for (i = 0; i < 6; i++) {
585             ff_msmpeg4_encode_block(s, block[i], i);
586         }
587         s->i_tex_bits += get_bits_diff(s);
588         s->i_count++;
589     }
590 }
591
592 #endif //CONFIG_ENCODERS
593
594 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
595                                     int32_t **dc_val_ptr)
596 {
597     int i;
598
599     if (n < 4) {
600         i= 0;
601     } else {
602         i= n-3;
603     }
604
605     *dc_val_ptr= &s->last_dc[i];
606     return s->last_dc[i];
607 }
608
609 static int get_dc(uint8_t *src, int stride, int scale)
610 {
611     int y;
612     int sum=0;
613     for(y=0; y<8; y++){
614         int x;
615         for(x=0; x<8; x++){
616             sum+=src[x + y*stride];
617         }
618     }
619     return FASTDIV((sum + (scale>>1)), scale);
620 }
621
622 /* dir = 0: left, dir = 1: top prediction */
623 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
624                              int16_t **dc_val_ptr, int *dir_ptr)
625 {
626     int a, b, c, wrap, pred, scale;
627     int16_t *dc_val;
628
629     /* find prediction */
630     if (n < 4) {
631         scale = s->y_dc_scale;
632     } else {
633         scale = s->c_dc_scale;
634     }
635
636     wrap = s->block_wrap[n];
637     dc_val= s->dc_val[0] + s->block_index[n];
638
639     /* B C
640      * A X
641      */
642     a = dc_val[ - 1];
643     b = dc_val[ - 1 - wrap];
644     c = dc_val[ - wrap];
645
646     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
647         b=c=1024;
648     }
649
650     /* XXX: the following solution consumes divisions, but it does not
651        necessitate to modify mpegvideo.c. The problem comes from the
652        fact they decided to store the quantized DC (which would lead
653        to problems if Q could vary !) */
654 #if ARCH_X86 && !defined PIC
655     __asm__ volatile(
656         "movl %3, %%eax         \n\t"
657         "shrl $1, %%eax         \n\t"
658         "addl %%eax, %2         \n\t"
659         "addl %%eax, %1         \n\t"
660         "addl %0, %%eax         \n\t"
661         "mull %4                \n\t"
662         "movl %%edx, %0         \n\t"
663         "movl %1, %%eax         \n\t"
664         "mull %4                \n\t"
665         "movl %%edx, %1         \n\t"
666         "movl %2, %%eax         \n\t"
667         "mull %4                \n\t"
668         "movl %%edx, %2         \n\t"
669         : "+b" (a), "+c" (b), "+D" (c)
670         : "g" (scale), "S" (ff_inverse[scale])
671         : "%eax", "%edx"
672     );
673 #else
674     /* #elif ARCH_ALPHA */
675     /* Divisions are extremely costly on Alpha; optimize the most
676        common case. But they are costly everywhere...
677      */
678     if (scale == 8) {
679         a = (a + (8 >> 1)) / 8;
680         b = (b + (8 >> 1)) / 8;
681         c = (c + (8 >> 1)) / 8;
682     } else {
683         a = FASTDIV((a + (scale >> 1)), scale);
684         b = FASTDIV((b + (scale >> 1)), scale);
685         c = FASTDIV((c + (scale >> 1)), scale);
686     }
687 #endif
688     /* XXX: WARNING: they did not choose the same test as MPEG4. This
689        is very important ! */
690     if(s->msmpeg4_version>3){
691         if(s->inter_intra_pred){
692             uint8_t *dest;
693             int wrap;
694
695             if(n==1){
696                 pred=a;
697                 *dir_ptr = 0;
698             }else if(n==2){
699                 pred=c;
700                 *dir_ptr = 1;
701             }else if(n==3){
702                 if (abs(a - b) < abs(b - c)) {
703                     pred = c;
704                     *dir_ptr = 1;
705                 } else {
706                     pred = a;
707                     *dir_ptr = 0;
708                 }
709             }else{
710                 if(n<4){
711                     wrap= s->linesize;
712                     dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
713                 }else{
714                     wrap= s->uvlinesize;
715                     dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
716                 }
717                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
718                 else           a= get_dc(dest-8, wrap, scale*8);
719                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
720                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
721
722                 if (s->h263_aic_dir==0) {
723                     pred= a;
724                     *dir_ptr = 0;
725                 }else if (s->h263_aic_dir==1) {
726                     if(n==0){
727                         pred= c;
728                         *dir_ptr = 1;
729                     }else{
730                         pred= a;
731                         *dir_ptr = 0;
732                     }
733                 }else if (s->h263_aic_dir==2) {
734                     if(n==0){
735                         pred= a;
736                         *dir_ptr = 0;
737                     }else{
738                         pred= c;
739                         *dir_ptr = 1;
740                     }
741                 } else {
742                     pred= c;
743                     *dir_ptr = 1;
744                 }
745             }
746         }else{
747             if (abs(a - b) < abs(b - c)) {
748                 pred = c;
749                 *dir_ptr = 1;
750             } else {
751                 pred = a;
752                 *dir_ptr = 0;
753             }
754         }
755     }else{
756         if (abs(a - b) <= abs(b - c)) {
757             pred = c;
758             *dir_ptr = 1;
759         } else {
760             pred = a;
761             *dir_ptr = 0;
762         }
763     }
764
765     /* update predictor */
766     *dc_val_ptr = &dc_val[0];
767     return pred;
768 }
769
770 #define DC_MAX 119
771
772 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
773 {
774     int sign, code;
775     int pred, extquant;
776     int extrabits = 0;
777
778     if(s->msmpeg4_version==1){
779         int32_t *dc_val;
780         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
781
782         /* update predictor */
783         *dc_val= level;
784     }else{
785         int16_t *dc_val;
786         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
787
788         /* update predictor */
789         if (n < 4) {
790             *dc_val = level * s->y_dc_scale;
791         } else {
792             *dc_val = level * s->c_dc_scale;
793         }
794     }
795
796     /* do the prediction */
797     level -= pred;
798
799     if(s->msmpeg4_version<=2){
800         if (n < 4) {
801             put_bits(&s->pb,
802                      v2_dc_lum_table[level+256][1],
803                      v2_dc_lum_table[level+256][0]);
804         }else{
805             put_bits(&s->pb,
806                      v2_dc_chroma_table[level+256][1],
807                      v2_dc_chroma_table[level+256][0]);
808         }
809     }else{
810         sign = 0;
811         if (level < 0) {
812             level = -level;
813             sign = 1;
814         }
815         code = level;
816         if (code > DC_MAX)
817             code = DC_MAX;
818         else if( s->msmpeg4_version>=6 ) {
819             if( s->qscale == 1 ) {
820                 extquant = (level + 3) & 0x3;
821                 code  = ((level+3)>>2);
822             } else if( s->qscale == 2 ) {
823                 extquant = (level + 1) & 0x1;
824                 code  = ((level+1)>>1);
825             }
826         }
827
828         if (s->dc_table_index == 0) {
829             if (n < 4) {
830                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
831             } else {
832                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
833             }
834         } else {
835             if (n < 4) {
836                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
837             } else {
838                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
839             }
840         }
841
842         if(s->msmpeg4_version>=6 && s->qscale<=2)
843             extrabits = 3 - s->qscale;
844
845         if (code == DC_MAX)
846             put_bits(&s->pb, 8 + extrabits, level);
847         else if(extrabits > 0)//== VC1 && s->qscale<=2
848             put_bits(&s->pb, extrabits, extquant);
849
850         if (level != 0) {
851             put_bits(&s->pb, 1, sign);
852         }
853     }
854 }
855
856 /* Encoding of a block. Very similar to MPEG4 except for a different
857    escape coding (same as H263) and more vlc tables.
858  */
859 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
860 {
861     int level, run, last, i, j, last_index;
862     int last_non_zero, sign, slevel;
863     int code, run_diff, dc_pred_dir;
864     const RLTable *rl;
865     const uint8_t *scantable;
866
867     if (s->mb_intra) {
868         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
869         i = 1;
870         if (n < 4) {
871             rl = &rl_table[s->rl_table_index];
872         } else {
873             rl = &rl_table[3 + s->rl_chroma_table_index];
874         }
875         run_diff = s->msmpeg4_version>=4;
876         scantable= s->intra_scantable.permutated;
877     } else {
878         i = 0;
879         rl = &rl_table[3 + s->rl_table_index];
880         if(s->msmpeg4_version<=2)
881             run_diff = 0;
882         else
883             run_diff = 1;
884         scantable= s->inter_scantable.permutated;
885     }
886
887     /* recalculate block_last_index for M$ wmv1 */
888     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
889         for(last_index=63; last_index>=0; last_index--){
890             if(block[scantable[last_index]]) break;
891         }
892         s->block_last_index[n]= last_index;
893     }else
894         last_index = s->block_last_index[n];
895     /* AC coefs */
896     last_non_zero = i - 1;
897     for (; i <= last_index; i++) {
898         j = scantable[i];
899         level = block[j];
900         if (level) {
901             run = i - last_non_zero - 1;
902             last = (i == last_index);
903             sign = 0;
904             slevel = level;
905             if (level < 0) {
906                 sign = 1;
907                 level = -level;
908             }
909
910             if(level<=MAX_LEVEL && run<=MAX_RUN){
911                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
912             }
913 #if 0
914 else
915     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
916 #endif
917             code = get_rl_index(rl, last, run, level);
918             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
919             if (code == rl->n) {
920                 int level1, run1;
921
922                 level1 = level - rl->max_level[last][run];
923                 if (level1 < 1)
924                     goto esc2;
925                 code = get_rl_index(rl, last, run, level1);
926                 if (code == rl->n) {
927                 esc2:
928                     put_bits(&s->pb, 1, 0);
929                     if (level > MAX_LEVEL)
930                         goto esc3;
931                     run1 = run - rl->max_run[last][level] - run_diff;
932                     if (run1 < 0)
933                         goto esc3;
934                     code = get_rl_index(rl, last, run1+1, level);
935                     if (s->msmpeg4_version == 4 && code == rl->n)
936                         goto esc3;
937                     code = get_rl_index(rl, last, run1, level);
938                     if (code == rl->n) {
939                     esc3:
940                         /* third escape */
941                         put_bits(&s->pb, 1, 0);
942                         put_bits(&s->pb, 1, last);
943                         if(s->msmpeg4_version>=4){
944                             if(s->esc3_level_length==0){
945                                 s->esc3_level_length=8;
946                                 s->esc3_run_length= 6;
947                                 //ESCLVLSZ + ESCRUNSZ
948                                 if(s->qscale<8)
949                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
950                                 else
951                                     put_bits(&s->pb, 8, 3);
952                             }
953                             put_bits(&s->pb, s->esc3_run_length, run);
954                             put_bits(&s->pb, 1, sign);
955                             put_bits(&s->pb, s->esc3_level_length, level);
956                         }else{
957                             put_bits(&s->pb, 6, run);
958                             put_sbits(&s->pb, 8, slevel);
959                         }
960                     } else {
961                         /* second escape */
962                         put_bits(&s->pb, 1, 1);
963                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
964                         put_bits(&s->pb, 1, sign);
965                     }
966                 } else {
967                     /* first escape */
968                     put_bits(&s->pb, 1, 1);
969                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
970                     put_bits(&s->pb, 1, sign);
971                 }
972             } else {
973                 put_bits(&s->pb, 1, sign);
974             }
975             last_non_zero = i;
976         }
977     }
978 }
979
980 /****************************************/
981 /* decoding stuff */
982
983 VLC ff_mb_non_intra_vlc[4];
984 static VLC v2_dc_lum_vlc;
985 static VLC v2_dc_chroma_vlc;
986 static VLC cbpy_vlc;
987 static VLC v2_intra_cbpc_vlc;
988 static VLC v2_mb_type_vlc;
989 static VLC v2_mv_vlc;
990 static VLC v1_intra_cbpc_vlc;
991 static VLC v1_inter_cbpc_vlc;
992 VLC ff_inter_intra_vlc;
993
994 /* This table is practically identical to the one from h263
995  * except that it is inverted. */
996 static av_cold void init_h263_dc_for_msmpeg4(void)
997 {
998         int level, uni_code, uni_len;
999
1000         for(level=-256; level<256; level++){
1001             int size, v, l;
1002             /* find number of bits */
1003             size = 0;
1004             v = abs(level);
1005             while (v) {
1006                 v >>= 1;
1007                     size++;
1008             }
1009
1010             if (level < 0)
1011                 l= (-level) ^ ((1 << size) - 1);
1012             else
1013                 l= level;
1014
1015             /* luminance h263 */
1016             uni_code= DCtab_lum[size][0];
1017             uni_len = DCtab_lum[size][1];
1018             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1019
1020             if (size > 0) {
1021                 uni_code<<=size; uni_code|=l;
1022                 uni_len+=size;
1023                 if (size > 8){
1024                     uni_code<<=1; uni_code|=1;
1025                     uni_len++;
1026                 }
1027             }
1028             v2_dc_lum_table[level+256][0]= uni_code;
1029             v2_dc_lum_table[level+256][1]= uni_len;
1030
1031             /* chrominance h263 */
1032             uni_code= DCtab_chrom[size][0];
1033             uni_len = DCtab_chrom[size][1];
1034             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1035
1036             if (size > 0) {
1037                 uni_code<<=size; uni_code|=l;
1038                 uni_len+=size;
1039                 if (size > 8){
1040                     uni_code<<=1; uni_code|=1;
1041                     uni_len++;
1042                 }
1043             }
1044             v2_dc_chroma_table[level+256][0]= uni_code;
1045             v2_dc_chroma_table[level+256][1]= uni_len;
1046
1047         }
1048 }
1049
1050 /* init all vlc decoding tables */
1051 av_cold int ff_msmpeg4_decode_init(MpegEncContext *s)
1052 {
1053     static int done = 0;
1054     int i;
1055     MVTable *mv;
1056
1057     common_init(s);
1058
1059     if (!done) {
1060         done = 1;
1061
1062         for(i=0;i<NB_RL_TABLES;i++) {
1063             init_rl(&rl_table[i], static_rl_table_store[i]);
1064         }
1065         INIT_VLC_RL(rl_table[0], 642);
1066         INIT_VLC_RL(rl_table[1], 1104);
1067         INIT_VLC_RL(rl_table[2], 554);
1068         INIT_VLC_RL(rl_table[3], 940);
1069         INIT_VLC_RL(rl_table[4], 962);
1070         INIT_VLC_RL(rl_table[5], 554);
1071
1072         mv = &mv_tables[0];
1073         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1074                     mv->table_mv_bits, 1, 1,
1075                     mv->table_mv_code, 2, 2, 3714);
1076         mv = &mv_tables[1];
1077         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1078                     mv->table_mv_bits, 1, 1,
1079                     mv->table_mv_code, 2, 2, 2694);
1080
1081         INIT_VLC_STATIC(&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, 1158);
1084         INIT_VLC_STATIC(&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, 1118);
1087         INIT_VLC_STATIC(&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, 1476);
1090         INIT_VLC_STATIC(&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, 1216);
1093
1094         INIT_VLC_STATIC(&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, 1472);
1097         INIT_VLC_STATIC(&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, 1506);
1100
1101         INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
1102                  &cbpy_tab[0][1], 2, 1,
1103                  &cbpy_tab[0][0], 2, 1, 64);
1104         INIT_VLC_STATIC(&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, 8);
1107         INIT_VLC_STATIC(&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, 128);
1110         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1111                  &mvtab[0][1], 2, 1,
1112                  &mvtab[0][0], 2, 1, 538);
1113
1114         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1115                      &wmv2_inter_table[0][0][1], 8, 4,
1116                      &wmv2_inter_table[0][0][0], 8, 4, 1636);
1117         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1118                      &wmv2_inter_table[1][0][1], 8, 4,
1119                      &wmv2_inter_table[1][0][0], 8, 4, 2648);
1120         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1121                      &wmv2_inter_table[2][0][1], 8, 4,
1122                      &wmv2_inter_table[2][0][0], 8, 4, 1532);
1123         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1124                      &wmv2_inter_table[3][0][1], 8, 4,
1125                      &wmv2_inter_table[3][0][0], 8, 4, 2488);
1126
1127         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1128                  &ff_msmp4_mb_i_table[0][1], 4, 2,
1129                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1130
1131         INIT_VLC_STATIC(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1132                  intra_MCBPC_bits, 1, 1,
1133                  intra_MCBPC_code, 1, 1, 64);
1134         INIT_VLC_STATIC(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1135                  inter_MCBPC_bits, 1, 1,
1136                  inter_MCBPC_code, 1, 1, 104);
1137
1138         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1139                  &table_inter_intra[0][1], 2, 1,
1140                  &table_inter_intra[0][0], 2, 1, 8);
1141     }
1142
1143     switch(s->msmpeg4_version){
1144     case 1:
1145     case 2:
1146         s->decode_mb= msmpeg4v12_decode_mb;
1147         break;
1148     case 3:
1149     case 4:
1150         s->decode_mb= msmpeg4v34_decode_mb;
1151         break;
1152     case 5:
1153         if (CONFIG_WMV2_DECODER)
1154             s->decode_mb= ff_wmv2_decode_mb;
1155     case 6:
1156         //FIXME + TODO VC1 decode mb
1157         break;
1158     }
1159
1160     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1161
1162     return 0;
1163 }
1164
1165 int msmpeg4_decode_picture_header(MpegEncContext * s)
1166 {
1167     int code;
1168
1169 #if 0
1170 {
1171 int i;
1172 for(i=0; i<s->gb.size_in_bits; i++)
1173     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1174 //    get_bits1(&s->gb);
1175 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1176 return -1;
1177 }
1178 #endif
1179
1180     if(s->msmpeg4_version==1){
1181         int start_code;
1182         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1183         if(start_code!=0x00000100){
1184             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1185             return -1;
1186         }
1187
1188         skip_bits(&s->gb, 5); // frame number */
1189     }
1190
1191     s->pict_type = get_bits(&s->gb, 2) + 1;
1192     if (s->pict_type != FF_I_TYPE &&
1193         s->pict_type != FF_P_TYPE){
1194         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1195         return -1;
1196     }
1197 #if 0
1198 {
1199     static int had_i=0;
1200     if(s->pict_type == FF_I_TYPE) had_i=1;
1201     if(!had_i) return -1;
1202 }
1203 #endif
1204     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1205     if(s->qscale==0){
1206         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1207         return -1;
1208     }
1209
1210     if (s->pict_type == FF_I_TYPE) {
1211         code = get_bits(&s->gb, 5);
1212         if(s->msmpeg4_version==1){
1213             if(code==0 || code>s->mb_height){
1214                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1215                 return -1;
1216             }
1217
1218             s->slice_height = code;
1219         }else{
1220             /* 0x17: one slice, 0x18: two slices, ... */
1221             if (code < 0x17){
1222                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1223                 return -1;
1224             }
1225
1226             s->slice_height = s->mb_height / (code - 0x16);
1227         }
1228
1229         switch(s->msmpeg4_version){
1230         case 1:
1231         case 2:
1232             s->rl_chroma_table_index = 2;
1233             s->rl_table_index = 2;
1234
1235             s->dc_table_index = 0; //not used
1236             break;
1237         case 3:
1238             s->rl_chroma_table_index = decode012(&s->gb);
1239             s->rl_table_index = decode012(&s->gb);
1240
1241             s->dc_table_index = get_bits1(&s->gb);
1242             break;
1243         case 4:
1244             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1245
1246             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1247             else                           s->per_mb_rl_table= 0;
1248
1249             if(!s->per_mb_rl_table){
1250                 s->rl_chroma_table_index = decode012(&s->gb);
1251                 s->rl_table_index = decode012(&s->gb);
1252             }
1253
1254             s->dc_table_index = get_bits1(&s->gb);
1255             s->inter_intra_pred= 0;
1256             break;
1257         }
1258         s->no_rounding = 1;
1259         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1260             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1261                 s->qscale,
1262                 s->rl_chroma_table_index,
1263                 s->rl_table_index,
1264                 s->dc_table_index,
1265                 s->per_mb_rl_table,
1266                 s->slice_height);
1267     } else {
1268         switch(s->msmpeg4_version){
1269         case 1:
1270         case 2:
1271             if(s->msmpeg4_version==1)
1272                 s->use_skip_mb_code = 1;
1273             else
1274                 s->use_skip_mb_code = get_bits1(&s->gb);
1275             s->rl_table_index = 2;
1276             s->rl_chroma_table_index = s->rl_table_index;
1277             s->dc_table_index = 0; //not used
1278             s->mv_table_index = 0;
1279             break;
1280         case 3:
1281             s->use_skip_mb_code = get_bits1(&s->gb);
1282             s->rl_table_index = decode012(&s->gb);
1283             s->rl_chroma_table_index = s->rl_table_index;
1284
1285             s->dc_table_index = get_bits1(&s->gb);
1286
1287             s->mv_table_index = get_bits1(&s->gb);
1288             break;
1289         case 4:
1290             s->use_skip_mb_code = get_bits1(&s->gb);
1291
1292             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1293             else                           s->per_mb_rl_table= 0;
1294
1295             if(!s->per_mb_rl_table){
1296                 s->rl_table_index = decode012(&s->gb);
1297                 s->rl_chroma_table_index = s->rl_table_index;
1298             }
1299
1300             s->dc_table_index = get_bits1(&s->gb);
1301
1302             s->mv_table_index = get_bits1(&s->gb);
1303             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1304             break;
1305         }
1306
1307         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1308             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1309                 s->use_skip_mb_code,
1310                 s->rl_table_index,
1311                 s->rl_chroma_table_index,
1312                 s->dc_table_index,
1313                 s->mv_table_index,
1314                 s->per_mb_rl_table,
1315                 s->qscale);
1316
1317         if(s->flipflop_rounding){
1318             s->no_rounding ^= 1;
1319         }else{
1320             s->no_rounding = 0;
1321         }
1322     }
1323 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1324
1325     s->esc3_level_length= 0;
1326     s->esc3_run_length= 0;
1327
1328 #ifdef DEBUG
1329     av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1330 #endif
1331     return 0;
1332 }
1333
1334 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1335 {
1336     int left= buf_size*8 - get_bits_count(&s->gb);
1337     int length= s->msmpeg4_version>=3 ? 17 : 16;
1338     /* the alt_bitstream reader could read over the end so we need to check it */
1339     if(left>=length && left<length+8)
1340     {
1341         int fps;
1342
1343         fps= get_bits(&s->gb, 5);
1344         s->bit_rate= get_bits(&s->gb, 11)*1024;
1345         if(s->msmpeg4_version>=3)
1346             s->flipflop_rounding= get_bits1(&s->gb);
1347         else
1348             s->flipflop_rounding= 0;
1349
1350 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1351     }
1352     else if(left<length+8)
1353     {
1354         s->flipflop_rounding= 0;
1355         if(s->msmpeg4_version != 2)
1356             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1357     }
1358     else
1359     {
1360         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1361     }
1362
1363     return 0;
1364 }
1365
1366 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1367 {
1368     int i;
1369     for(i=0;i<n;i++)
1370         tab[i] = val;
1371 }
1372
1373 #if CONFIG_ENCODERS
1374 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1375 {
1376     int range, bit_size, sign, code, bits;
1377
1378     if (val == 0) {
1379         /* zero vector */
1380         code = 0;
1381         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1382     } else {
1383         bit_size = s->f_code - 1;
1384         range = 1 << bit_size;
1385         if (val <= -64)
1386             val += 64;
1387         else if (val >= 64)
1388             val -= 64;
1389
1390         if (val >= 0) {
1391             sign = 0;
1392         } else {
1393             val = -val;
1394             sign = 1;
1395         }
1396         val--;
1397         code = (val >> bit_size) + 1;
1398         bits = val & (range - 1);
1399
1400         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1401         if (bit_size > 0) {
1402             put_bits(&s->pb, bit_size, bits);
1403         }
1404     }
1405 }
1406 #endif
1407
1408 /* This is identical to h263 except that its range is multiplied by 2. */
1409 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1410 {
1411     int code, val, sign, shift;
1412
1413     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1414 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1415     if (code < 0)
1416         return 0xffff;
1417
1418     if (code == 0)
1419         return pred;
1420     sign = get_bits1(&s->gb);
1421     shift = f_code - 1;
1422     val = code;
1423     if (shift) {
1424         val = (val - 1) << shift;
1425         val |= get_bits(&s->gb, shift);
1426         val++;
1427     }
1428     if (sign)
1429         val = -val;
1430
1431     val += pred;
1432     if (val <= -64)
1433         val += 64;
1434     else if (val >= 64)
1435         val -= 64;
1436
1437     return val;
1438 }
1439
1440 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1441 {
1442     int cbp, code, i;
1443
1444     if (s->pict_type == FF_P_TYPE) {
1445         if (s->use_skip_mb_code) {
1446             if (get_bits1(&s->gb)) {
1447                 /* skip mb */
1448                 s->mb_intra = 0;
1449                 for(i=0;i<6;i++)
1450                     s->block_last_index[i] = -1;
1451                 s->mv_dir = MV_DIR_FORWARD;
1452                 s->mv_type = MV_TYPE_16X16;
1453                 s->mv[0][0][0] = 0;
1454                 s->mv[0][0][1] = 0;
1455                 s->mb_skipped = 1;
1456                 return 0;
1457             }
1458         }
1459
1460         if(s->msmpeg4_version==2)
1461             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1462         else
1463             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1464         if(code<0 || code>7){
1465             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1466             return -1;
1467         }
1468
1469         s->mb_intra = code >>2;
1470
1471         cbp = code & 0x3;
1472     } else {
1473         s->mb_intra = 1;
1474         if(s->msmpeg4_version==2)
1475             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1476         else
1477             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1478         if(cbp<0 || cbp>3){
1479             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1480             return -1;
1481         }
1482     }
1483
1484     if (!s->mb_intra) {
1485         int mx, my, cbpy;
1486
1487         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1488         if(cbpy<0){
1489             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1490             return -1;
1491         }
1492
1493         cbp|= cbpy<<2;
1494         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1495
1496         h263_pred_motion(s, 0, 0, &mx, &my);
1497         mx= msmpeg4v2_decode_motion(s, mx, 1);
1498         my= msmpeg4v2_decode_motion(s, my, 1);
1499
1500         s->mv_dir = MV_DIR_FORWARD;
1501         s->mv_type = MV_TYPE_16X16;
1502         s->mv[0][0][0] = mx;
1503         s->mv[0][0][1] = my;
1504     } else {
1505         if(s->msmpeg4_version==2){
1506             s->ac_pred = get_bits1(&s->gb);
1507             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1508         } else{
1509             s->ac_pred = 0;
1510             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1511             if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1512         }
1513     }
1514
1515     s->dsp.clear_blocks(s->block[0]);
1516     for (i = 0; i < 6; i++) {
1517         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1518         {
1519              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1520              return -1;
1521         }
1522     }
1523     return 0;
1524 }
1525
1526 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1527 {
1528     int cbp, code, i;
1529     uint8_t *coded_val;
1530     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1531
1532     if (s->pict_type == FF_P_TYPE) {
1533         if (s->use_skip_mb_code) {
1534             if (get_bits1(&s->gb)) {
1535                 /* skip mb */
1536                 s->mb_intra = 0;
1537                 for(i=0;i<6;i++)
1538                     s->block_last_index[i] = -1;
1539                 s->mv_dir = MV_DIR_FORWARD;
1540                 s->mv_type = MV_TYPE_16X16;
1541                 s->mv[0][0][0] = 0;
1542                 s->mv[0][0][1] = 0;
1543                 s->mb_skipped = 1;
1544                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1545
1546                 return 0;
1547             }
1548         }
1549
1550         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1551         if (code < 0)
1552             return -1;
1553         //s->mb_intra = (code & 0x40) ? 0 : 1;
1554         s->mb_intra = (~code & 0x40) >> 6;
1555
1556         cbp = code & 0x3f;
1557     } else {
1558         s->mb_intra = 1;
1559         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1560         if (code < 0)
1561             return -1;
1562         /* predict coded block pattern */
1563         cbp = 0;
1564         for(i=0;i<6;i++) {
1565             int val = ((code >> (5 - i)) & 1);
1566             if (i < 4) {
1567                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1568                 val = val ^ pred;
1569                 *coded_val = val;
1570             }
1571             cbp |= val << (5 - i);
1572         }
1573     }
1574
1575     if (!s->mb_intra) {
1576         int mx, my;
1577 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1578         if(s->per_mb_rl_table && cbp){
1579             s->rl_table_index = decode012(&s->gb);
1580             s->rl_chroma_table_index = s->rl_table_index;
1581         }
1582         h263_pred_motion(s, 0, 0, &mx, &my);
1583         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1584             return -1;
1585         s->mv_dir = MV_DIR_FORWARD;
1586         s->mv_type = MV_TYPE_16X16;
1587         s->mv[0][0][0] = mx;
1588         s->mv[0][0][1] = my;
1589         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1590     } else {
1591 //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));
1592         s->ac_pred = get_bits1(&s->gb);
1593         *mb_type_ptr = MB_TYPE_INTRA;
1594         if(s->inter_intra_pred){
1595             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1596 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1597         }
1598         if(s->per_mb_rl_table && cbp){
1599             s->rl_table_index = decode012(&s->gb);
1600             s->rl_chroma_table_index = s->rl_table_index;
1601         }
1602     }
1603
1604     s->dsp.clear_blocks(s->block[0]);
1605     for (i = 0; i < 6; i++) {
1606         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1607         {
1608             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1609             return -1;
1610         }
1611     }
1612
1613     return 0;
1614 }
1615 //#define ERROR_DETAILS
1616 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1617                               int n, int coded, const uint8_t *scan_table)
1618 {
1619     int level, i, last, run, run_diff;
1620     int av_uninit(dc_pred_dir);
1621     RLTable *rl;
1622     RL_VLC_ELEM *rl_vlc;
1623     int qmul, qadd;
1624
1625     if (s->mb_intra) {
1626         qmul=1;
1627         qadd=0;
1628
1629         /* DC coef */
1630         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1631
1632         if (level < 0){
1633             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1634             if(s->inter_intra_pred) level=0;
1635             else                    return -1;
1636         }
1637         if (n < 4) {
1638             rl = &rl_table[s->rl_table_index];
1639             if(level > 256*s->y_dc_scale){
1640                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1641                 if(!s->inter_intra_pred) return -1;
1642             }
1643         } else {
1644             rl = &rl_table[3 + s->rl_chroma_table_index];
1645             if(level > 256*s->c_dc_scale){
1646                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1647                 if(!s->inter_intra_pred) return -1;
1648             }
1649         }
1650         block[0] = level;
1651
1652         run_diff = s->msmpeg4_version >= 4;
1653         i = 0;
1654         if (!coded) {
1655             goto not_coded;
1656         }
1657         if (s->ac_pred) {
1658             if (dc_pred_dir == 0)
1659                 scan_table = s->intra_v_scantable.permutated; /* left */
1660             else
1661                 scan_table = s->intra_h_scantable.permutated; /* top */
1662         } else {
1663             scan_table = s->intra_scantable.permutated;
1664         }
1665         rl_vlc= rl->rl_vlc[0];
1666     } else {
1667         qmul = s->qscale << 1;
1668         qadd = (s->qscale - 1) | 1;
1669         i = -1;
1670         rl = &rl_table[3 + s->rl_table_index];
1671
1672         if(s->msmpeg4_version==2)
1673             run_diff = 0;
1674         else
1675             run_diff = 1;
1676
1677         if (!coded) {
1678             s->block_last_index[n] = i;
1679             return 0;
1680         }
1681         if(!scan_table)
1682             scan_table = s->inter_scantable.permutated;
1683         rl_vlc= rl->rl_vlc[s->qscale];
1684     }
1685   {
1686     OPEN_READER(re, &s->gb);
1687     for(;;) {
1688         UPDATE_CACHE(re, &s->gb);
1689         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1690         if (level==0) {
1691             int cache;
1692             cache= GET_CACHE(re, &s->gb);
1693             /* escape */
1694             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1695                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1696                     /* third escape */
1697                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1698                     UPDATE_CACHE(re, &s->gb);
1699                     if(s->msmpeg4_version<=3){
1700                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1701                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1702                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1703                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1704                     }else{
1705                         int sign;
1706                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1707                         if(!s->esc3_level_length){
1708                             int ll;
1709                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1710                             if(s->qscale<8){
1711                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1712                                 if(ll==0){
1713                                     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");
1714                                     SKIP_BITS(re, &s->gb, 1);
1715                                     ll=8;
1716                                 }
1717                             }else{
1718                                 ll=2;
1719                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1720                                     ll++;
1721                                     SKIP_BITS(re, &s->gb, 1);
1722                                 }
1723                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1724                             }
1725
1726                             s->esc3_level_length= ll;
1727                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1728 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1729                             UPDATE_CACHE(re, &s->gb);
1730                         }
1731                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1732                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1733
1734                         sign=  SHOW_UBITS(re, &s->gb, 1);
1735                         SKIP_BITS(re, &s->gb, 1);
1736
1737                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1738                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1739                         if(sign) level= -level;
1740                     }
1741 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1742 #if 0 // waste of time / this will detect very few errors
1743                     {
1744                         const int abs_level= FFABS(level);
1745                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1746                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1747                             if(abs_level <= rl->max_level[last][run]){
1748                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1749                                 return DECODING_AC_LOST;
1750                             }
1751                             if(abs_level <= rl->max_level[last][run]*2){
1752                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1753                                 return DECODING_AC_LOST;
1754                             }
1755                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1756                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1757                                 return DECODING_AC_LOST;
1758                             }
1759                         }
1760                     }
1761 #endif
1762                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1763                     if (level>0) level= level * qmul + qadd;
1764                     else         level= level * qmul - qadd;
1765 #if 0 // waste of time too :(
1766                     if(level>2048 || level<-2048){
1767                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1768                         return DECODING_AC_LOST;
1769                     }
1770 #endif
1771                     i+= run + 1;
1772                     if(last) i+=192;
1773 #ifdef ERROR_DETAILS
1774                 if(run==66)
1775                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1776                 else if((i>62 && i<192) || i>192+63)
1777                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1778 #endif
1779                 } else {
1780                     /* second escape */
1781 #if MIN_CACHE_BITS < 23
1782                     LAST_SKIP_BITS(re, &s->gb, 2);
1783                     UPDATE_CACHE(re, &s->gb);
1784 #else
1785                     SKIP_BITS(re, &s->gb, 2);
1786 #endif
1787                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1788                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1789                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1790                     LAST_SKIP_BITS(re, &s->gb, 1);
1791 #ifdef ERROR_DETAILS
1792                 if(run==66)
1793                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1794                 else if((i>62 && i<192) || i>192+63)
1795                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1796 #endif
1797                 }
1798             } else {
1799                 /* first escape */
1800 #if MIN_CACHE_BITS < 22
1801                 LAST_SKIP_BITS(re, &s->gb, 1);
1802                 UPDATE_CACHE(re, &s->gb);
1803 #else
1804                 SKIP_BITS(re, &s->gb, 1);
1805 #endif
1806                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1807                 i+= run;
1808                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1809                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1810                 LAST_SKIP_BITS(re, &s->gb, 1);
1811 #ifdef ERROR_DETAILS
1812                 if(run==66)
1813                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1814                 else if((i>62 && i<192) || i>192+63)
1815                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1816 #endif
1817             }
1818         } else {
1819             i+= run;
1820             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1821             LAST_SKIP_BITS(re, &s->gb, 1);
1822 #ifdef ERROR_DETAILS
1823                 if(run==66)
1824                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1825                 else if((i>62 && i<192) || i>192+63)
1826                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1827 #endif
1828         }
1829         if (i > 62){
1830             i-= 192;
1831             if(i&(~63)){
1832                 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1833                 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1834                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1835                     break;
1836                 }else{
1837                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1838                     return -1;
1839                 }
1840             }
1841
1842             block[scan_table[i]] = level;
1843             break;
1844         }
1845
1846         block[scan_table[i]] = level;
1847     }
1848     CLOSE_READER(re, &s->gb);
1849   }
1850  not_coded:
1851     if (s->mb_intra) {
1852         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1853         if (s->ac_pred) {
1854             i = 63; /* XXX: not optimal */
1855         }
1856     }
1857     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1858     s->block_last_index[n] = i;
1859
1860     return 0;
1861 }
1862
1863 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1864 {
1865     int level, pred;
1866
1867     if(s->msmpeg4_version<=2){
1868         if (n < 4) {
1869             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1870         } else {
1871             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1872         }
1873         if (level < 0)
1874             return -1;
1875         level-=256;
1876     }else{  //FIXME optimize use unified tables & index
1877         if (n < 4) {
1878             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1879         } else {
1880             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1881         }
1882         if (level < 0){
1883             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1884             return -1;
1885         }
1886
1887         if (level == DC_MAX) {
1888             level = get_bits(&s->gb, 8);
1889             if (get_bits1(&s->gb))
1890                 level = -level;
1891         } else if (level != 0) {
1892             if (get_bits1(&s->gb))
1893                 level = -level;
1894         }
1895     }
1896
1897     if(s->msmpeg4_version==1){
1898         int32_t *dc_val;
1899         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1900         level += pred;
1901
1902         /* update predictor */
1903         *dc_val= level;
1904     }else{
1905         int16_t *dc_val;
1906         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1907         level += pred;
1908
1909         /* update predictor */
1910         if (n < 4) {
1911             *dc_val = level * s->y_dc_scale;
1912         } else {
1913             *dc_val = level * s->c_dc_scale;
1914         }
1915     }
1916
1917     return level;
1918 }
1919
1920 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1921                                  int *mx_ptr, int *my_ptr)
1922 {
1923     MVTable *mv;
1924     int code, mx, my;
1925
1926     mv = &mv_tables[s->mv_table_index];
1927
1928     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1929     if (code < 0){
1930         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1931         return -1;
1932     }
1933     if (code == mv->n) {
1934 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1935         mx = get_bits(&s->gb, 6);
1936         my = get_bits(&s->gb, 6);
1937     } else {
1938         mx = mv->table_mvx[code];
1939         my = mv->table_mvy[code];
1940     }
1941
1942     mx += *mx_ptr - 32;
1943     my += *my_ptr - 32;
1944     /* WARNING : they do not do exactly modulo encoding */
1945     if (mx <= -64)
1946         mx += 64;
1947     else if (mx >= 64)
1948         mx -= 64;
1949
1950     if (my <= -64)
1951         my += 64;
1952     else if (my >= 64)
1953         my -= 64;
1954     *mx_ptr = mx;
1955     *my_ptr = my;
1956     return 0;
1957 }