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