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