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