fixing msmpeg4v3 dc-scale for quantizers 24-31
[ffmpeg.git] / libavcodec / msmpeg4.c
1 /*
2  * MSMPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2001 Gerard Lantau.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include "common.h"
22 #include "dsputil.h"
23 #include "mpegvideo.h"
24 #include "avcodec.h"
25
26 /*
27  * You can also call this codec : MPEG4 with a twist ! 
28  *
29  * TODO: 
30  *        - (encoding) select best mv table (two choices)
31  *        - (encoding) select best vlc/dc table 
32  */
33 //#define DEBUG
34
35 /* motion vector table */
36 typedef struct MVTable {
37     int n;
38     const UINT16 *table_mv_code;
39     const UINT8 *table_mv_bits;
40     const UINT8 *table_mvx;
41     const UINT8 *table_mvy;
42     UINT16 *table_mv_index; /* encoding: convert mv to index in table_mv */
43     VLC vlc;                /* decoding: vlc */
44 } MVTable;
45
46 static UINT32 v2_dc_lum_table[512][2];
47 static UINT32 v2_dc_chroma_table[512][2];
48
49 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
50 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
51                                 int n, int coded);
52 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
53 static int msmpeg4_decode_motion(MpegEncContext * s, 
54                                  int *mx_ptr, int *my_ptr);
55 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
56 static void init_h263_dc_for_msmpeg4();
57
58
59 extern UINT32 inverse[256];
60
61 #ifdef DEBUG
62 int intra_count = 0;
63 int frame_count = 0;
64 #endif
65 /* XXX: move it to mpegvideo.h */
66
67 static int init_done = 0;
68
69 #include "msmpeg4data.h"
70
71 #ifdef STATS
72
73 const char *st_names[ST_NB] = {
74     "unknown",
75     "dc",
76     "intra_ac",
77     "inter_ac",
78     "intra_mb",
79     "inter_mb",
80     "mv",
81 };
82
83 int st_current_index = 0;
84 unsigned int st_bit_counts[ST_NB];
85 unsigned int st_out_bit_counts[ST_NB];
86
87 #define set_stat(var) st_current_index = var;
88
89 void print_stats(void)
90 {
91     unsigned int total;
92     int i;
93
94     printf("Input:\n");
95     total = 0;
96     for(i=0;i<ST_NB;i++)
97         total += st_bit_counts[i];
98     if (total == 0)
99         total = 1;
100     for(i=0;i<ST_NB;i++) {
101         printf("%-10s : %10.1f %5.1f%%\n", 
102                st_names[i], 
103                (double)st_bit_counts[i] / 8.0, 
104                (double)st_bit_counts[i] * 100.0 / total);
105     }
106     printf("%-10s : %10.1f %5.1f%%\n",
107            "total", 
108            (double)total / 8.0, 
109            100.0);
110
111     printf("Output:\n");
112     total = 0;
113     for(i=0;i<ST_NB;i++)
114         total += st_out_bit_counts[i];
115     if (total == 0)
116         total = 1;
117     for(i=0;i<ST_NB;i++) {
118         printf("%-10s : %10.1f %5.1f%%\n", 
119                st_names[i], 
120                (double)st_out_bit_counts[i] / 8.0, 
121                (double)st_out_bit_counts[i] * 100.0 / total);
122     }
123     printf("%-10s : %10.1f %5.1f%%\n",
124            "total", 
125            (double)total / 8.0, 
126            100.0);
127 }
128
129 #else
130
131 #define set_stat(var)
132
133 #endif
134
135 /* build the table which associate a (x,y) motion vector to a vlc */
136 static void init_mv_table(MVTable *tab)
137 {
138     int i, x, y;
139
140     tab->table_mv_index = malloc(sizeof(UINT16) * 4096);
141     /* mark all entries as not used */
142     for(i=0;i<4096;i++)
143         tab->table_mv_index[i] = tab->n;
144     
145     for(i=0;i<tab->n;i++) {
146         x = tab->table_mvx[i];
147         y = tab->table_mvy[i];
148         tab->table_mv_index[(x << 6) | y] = i;
149     }
150 }
151
152 static void code012(PutBitContext *pb, int n)
153 {
154     if (n == 0) {
155         put_bits(pb, 1, 0);
156     } else {
157         put_bits(pb, 1, 1);
158         put_bits(pb, 1, (n >= 2));
159     }
160 }
161
162 /* write MSMPEG4 V3 compatible frame header */
163 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
164 {
165     int i;
166
167     align_put_bits(&s->pb);
168
169     put_bits(&s->pb, 2, s->pict_type - 1);
170
171     put_bits(&s->pb, 5, s->qscale);
172
173     s->rl_table_index = 2;
174     if(s->msmpeg4_version==2)
175         s->rl_chroma_table_index = 2; /* only for I frame */
176     else
177         s->rl_chroma_table_index = 1; /* only for I frame */
178
179     s->dc_table_index = 1;
180     s->mv_table_index = 1; /* only if P frame */
181     s->use_skip_mb_code = 1; /* only if P frame */
182     
183     if (s->pict_type == I_TYPE) {
184         put_bits(&s->pb, 5, 0x17); /* indicate only one "slice" */
185
186         if(s->msmpeg4_version!=2){
187             code012(&s->pb, s->rl_chroma_table_index);
188             code012(&s->pb, s->rl_table_index);
189
190             put_bits(&s->pb, 1, s->dc_table_index);
191         }
192         s->no_rounding = 1;
193     } else {
194         put_bits(&s->pb, 1, s->use_skip_mb_code);
195         
196         s->rl_chroma_table_index = s->rl_table_index;
197         if(s->msmpeg4_version!=2){
198             code012(&s->pb, s->rl_table_index);
199
200             put_bits(&s->pb, 1, s->dc_table_index);
201
202             put_bits(&s->pb, 1, s->mv_table_index);
203         }
204
205         if(s->flipflop_rounding){
206             s->no_rounding ^= 1;
207         }else{
208             s->no_rounding = 0;
209         }
210     }
211
212     if (!init_done) {
213         /* init various encoding tables */
214         init_done = 1;
215         init_mv_table(&mv_tables[0]);
216         init_mv_table(&mv_tables[1]);
217         for(i=0;i<NB_RL_TABLES;i++)
218             init_rl(&rl_table[i]);
219
220         init_h263_dc_for_msmpeg4();
221     }
222
223 #ifdef DEBUG
224     intra_count = 0;
225     printf("*****frame %d:\n", frame_count++);
226 #endif
227 }
228
229 void msmpeg4_encode_ext_header(MpegEncContext * s)
230 {
231         s->flipflop_rounding=1;
232         s->bitrate= 910; // FIXME
233
234         put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
235
236         put_bits(&s->pb, 11, s->bitrate);
237
238         put_bits(&s->pb, 1, s->flipflop_rounding);
239 }
240
241 /* predict coded block */
242 static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
243 {
244     int xy, wrap, pred, a, b, c;
245
246     xy = s->block_index[n];
247     wrap = s->block_wrap[0];
248
249     /* B C
250      * A X 
251      */
252     a = s->coded_block[xy - 1       ];
253     b = s->coded_block[xy - 1 - wrap];
254     c = s->coded_block[xy     - wrap];
255     
256     if (b == c) {
257         pred = a;
258     } else {
259         pred = c;
260     }
261     
262     /* store value */
263     *coded_block_ptr = &s->coded_block[xy];
264
265     return pred;
266 }
267
268 static void msmpeg4_encode_motion(MpegEncContext * s, 
269                                   int mx, int my)
270 {
271     int code;
272     MVTable *mv;
273
274     /* modulo encoding */
275     /* WARNING : you cannot reach all the MVs even with the modulo
276        encoding. This is a somewhat strange compromise they took !!!  */
277     if (mx <= -64)
278         mx += 64;
279     else if (mx >= 64)
280         mx -= 64;
281     if (my <= -64)
282         my += 64;
283     else if (my >= 64)
284         my -= 64;
285     
286     mx += 32;
287     my += 32;
288 #if 0
289     if ((unsigned)mx >= 64 ||
290         (unsigned)my >= 64) 
291         fprintf(stderr, "error mx=%d my=%d\n", mx, my);
292 #endif
293     mv = &mv_tables[s->mv_table_index];
294
295     code = mv->table_mv_index[(mx << 6) | my];
296     set_stat(ST_MV);
297     put_bits(&s->pb, 
298              mv->table_mv_bits[code], 
299              mv->table_mv_code[code]);
300     if (code == mv->n) {
301         /* escape : code litterally */
302         put_bits(&s->pb, 6, mx);
303         put_bits(&s->pb, 6, my);
304     }
305 }
306
307 void msmpeg4_encode_mb(MpegEncContext * s, 
308                        DCTELEM block[6][64],
309                        int motion_x, int motion_y)
310 {
311     int cbp, coded_cbp, i;
312     int pred_x, pred_y;
313     UINT8 *coded_block;
314
315     if (!s->mb_intra) {
316         /* compute cbp */
317         set_stat(ST_INTER_MB);
318         cbp = 0;
319         for (i = 0; i < 6; i++) {
320             if (s->block_last_index[i] >= 0)
321                 cbp |= 1 << (5 - i);
322         }
323         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
324             /* skip macroblock */
325             put_bits(&s->pb, 1, 1);
326             return;
327         }
328         if (s->use_skip_mb_code)
329             put_bits(&s->pb, 1, 0);     /* mb coded */
330         
331         if(s->msmpeg4_version==2){
332             put_bits(&s->pb, 
333                      v2_mb_type[cbp&3][1], 
334                      v2_mb_type[cbp&3][0]);
335             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
336             else             coded_cbp= cbp;
337
338             put_bits(&s->pb, 
339                      cbpy_tab[coded_cbp>>2][1], 
340                      cbpy_tab[coded_cbp>>2][0]);
341                         
342             h263_pred_motion(s, 0, &pred_x, &pred_y);
343             msmpeg4v2_encode_motion(s, motion_x - pred_x);
344             msmpeg4v2_encode_motion(s, motion_y - pred_y);
345         }else{
346             put_bits(&s->pb, 
347                      table_mb_non_intra[cbp + 64][1], 
348                      table_mb_non_intra[cbp + 64][0]);
349
350             /* motion vector */
351             h263_pred_motion(s, 0, &pred_x, &pred_y);
352             msmpeg4_encode_motion(s, motion_x - pred_x, 
353                                   motion_y - pred_y);
354         }
355     } else {
356         /* compute cbp */
357         cbp = 0;
358         coded_cbp = 0;
359         for (i = 0; i < 6; i++) {
360             int val, pred;
361             val = (s->block_last_index[i] >= 1);
362             cbp |= val << (5 - i);
363             if (i < 4) {
364                 /* predict value for close blocks only for luma */
365                 pred = coded_block_pred(s, i, &coded_block);
366                 *coded_block = val;
367                 val = val ^ pred;
368             }
369             coded_cbp |= val << (5 - i);
370         }
371 #if 0
372         if (coded_cbp)
373             printf("cbp=%x %x\n", cbp, coded_cbp);
374 #endif
375
376         if(s->msmpeg4_version==2){
377             if (s->pict_type == I_TYPE) {
378                 put_bits(&s->pb, 
379                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
380             } else {
381                 if (s->use_skip_mb_code)
382                     put_bits(&s->pb, 1, 0);     /* mb coded */
383                 put_bits(&s->pb, 
384                          v2_mb_type[(cbp&3) + 4][1], 
385                          v2_mb_type[(cbp&3) + 4][0]);
386             }
387             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
388             put_bits(&s->pb, 
389                      cbpy_tab[cbp>>2][1], 
390                      cbpy_tab[cbp>>2][0]);
391         }else{
392             if (s->pict_type == I_TYPE) {
393                 set_stat(ST_INTRA_MB);
394                 put_bits(&s->pb, 
395                          table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
396             } else {
397                 if (s->use_skip_mb_code)
398                     put_bits(&s->pb, 1, 0);     /* mb coded */
399                 put_bits(&s->pb, 
400                          table_mb_non_intra[cbp][1], 
401                          table_mb_non_intra[cbp][0]);
402             }
403             set_stat(ST_INTRA_MB);
404             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
405         }
406     }
407
408     for (i = 0; i < 6; i++) {
409         msmpeg4_encode_block(s, block[i], i);
410     }
411 }
412
413
414 #if 0
415 /* identical to mpeg4 for msmpeg4v3 but not msmpeg4v2 */
416 void msmpeg4_dc_scale(MpegEncContext * s)
417 {
418     if (s->qscale < 5 || s->msmpeg4_version==2){
419         s->y_dc_scale = 8;
420         s->c_dc_scale = 8;
421     }else if (s->qscale < 9){
422         s->y_dc_scale = 2 * s->qscale;
423         s->c_dc_scale = (s->qscale + 13)>>1;
424     }else if(s->qscale < 25){
425         s->y_dc_scale = s->qscale + 8;
426         s->c_dc_scale = (s->qscale + 13)>>1;
427     }else{
428         s->y_dc_scale = 2 * s->qscale - 16;
429         s->c_dc_scale = s->qscale - 6;
430     }
431 }
432 #endif
433
434 /* dir = 0: left, dir = 1: top prediction */
435 static int msmpeg4_pred_dc(MpegEncContext * s, int n, 
436                            INT16 **dc_val_ptr, int *dir_ptr)
437 {
438     int a, b, c, wrap, pred, scale;
439     INT16 *dc_val;
440
441     /* find prediction */
442     if (n < 4) {
443         scale = s->y_dc_scale;
444     } else {
445         scale = s->c_dc_scale;
446     }
447     wrap = s->block_wrap[n];
448     dc_val= s->dc_val[0] + s->block_index[n];
449
450     /* B C
451      * A X 
452      */
453     a = dc_val[ - 1];
454     b = dc_val[ - 1 - wrap];
455     c = dc_val[ - wrap];
456
457     /* XXX: the following solution consumes divisions, but it does not
458        necessitate to modify mpegvideo.c. The problem comes from the
459        fact they decided to store the quantized DC (which would lead
460        to problems if Q could vary !) */
461 #if defined ARCH_X86 && !defined PIC
462     asm volatile(
463         "movl %3, %%eax         \n\t"
464         "shrl $1, %%eax         \n\t"
465         "addl %%eax, %2         \n\t"
466         "addl %%eax, %1         \n\t"
467         "addl %0, %%eax         \n\t"
468         "mull %4                \n\t"
469         "movl %%edx, %0         \n\t"
470         "movl %1, %%eax         \n\t"
471         "mull %4                \n\t"
472         "movl %%edx, %1         \n\t"
473         "movl %2, %%eax         \n\t"
474         "mull %4                \n\t"
475         "movl %%edx, %2         \n\t"
476         : "+b" (a), "+c" (b), "+D" (c)
477         : "g" (scale), "S" (inverse[scale])
478         : "%eax", "%edx"
479     );
480 #else
481     /* #elif defined (ARCH_ALPHA) */
482     /* Divisions are extremely costly on Alpha; optimize the most
483        common case. But they are costly everywhere...
484      */
485     if (scale == 8) {
486         a = (a + (8 >> 1)) / 8;
487         b = (b + (8 >> 1)) / 8;
488         c = (c + (8 >> 1)) / 8;
489     } else {
490         a = (a + (scale >> 1)) / scale;
491         b = (b + (scale >> 1)) / scale;
492         c = (c + (scale >> 1)) / scale;
493     }
494 #endif
495     /* XXX: WARNING: they did not choose the same test as MPEG4. This
496        is very important ! */
497     if (abs(a - b) <= abs(b - c)) {
498         pred = c;
499         *dir_ptr = 1;
500     } else {
501         pred = a;
502         *dir_ptr = 0;
503     }
504
505     /* update predictor */
506     *dc_val_ptr = &dc_val[0];
507     return pred;
508 }
509
510 #define DC_MAX 119
511
512 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
513 {
514     int sign, code;
515     int pred;
516     INT16 *dc_val;
517
518     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
519
520     /* update predictor */
521     if (n < 4) {
522         *dc_val = level * s->y_dc_scale;
523     } else {
524         *dc_val = level * s->c_dc_scale;
525     }
526
527     /* do the prediction */
528     level -= pred;
529
530     if(s->msmpeg4_version==2){
531         if (n < 4) {
532             put_bits(&s->pb, 
533                      v2_dc_lum_table[level+256][1],
534                      v2_dc_lum_table[level+256][0]);
535         }else{
536             put_bits(&s->pb, 
537                      v2_dc_chroma_table[level+256][1],
538                      v2_dc_chroma_table[level+256][0]);
539         }
540     }else{
541         sign = 0;
542         if (level < 0) {
543             level = -level;
544             sign = 1;
545         }
546         code = level;
547         if (code > DC_MAX) 
548             code = DC_MAX;
549
550         if (s->dc_table_index == 0) {
551             if (n < 4) {
552                 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
553             } else {
554                 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
555             }
556         } else {
557             if (n < 4) {
558                 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
559             } else {
560                 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
561             }
562         }
563             
564         if (code == DC_MAX)
565             put_bits(&s->pb, 8, level);
566             
567         if (level != 0) {
568             put_bits(&s->pb, 1, sign);
569         }
570     }
571 }
572
573 /* Encoding of a block. Very similar to MPEG4 except for a different
574    escape coding (same as H263) and more vlc tables.
575  */
576 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
577 {
578     int level, run, last, i, j, last_index;
579     int last_non_zero, sign, slevel;
580     int code, run_diff, dc_pred_dir;
581     const RLTable *rl;
582
583     if (s->mb_intra) {
584         set_stat(ST_DC);
585         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
586         i = 1;
587         if (n < 4) {
588             rl = &rl_table[s->rl_table_index];
589         } else {
590             rl = &rl_table[3 + s->rl_chroma_table_index];
591         }
592         run_diff = 0;
593         set_stat(ST_INTRA_AC);
594     } else {
595         i = 0;
596         rl = &rl_table[3 + s->rl_table_index];
597         if(s->msmpeg4_version==2)
598             run_diff = 0;
599         else
600             run_diff = 1;
601         set_stat(ST_INTER_AC);
602     }
603
604     /* AC coefs */
605     last_index = s->block_last_index[n];
606     last_non_zero = i - 1;
607     for (; i <= last_index; i++) {
608         j = zigzag_direct[i];
609         level = block[j];
610         if (level) {
611             run = i - last_non_zero - 1;
612             last = (i == last_index);
613             sign = 0;
614             slevel = level;
615             if (level < 0) {
616                 sign = 1;
617                 level = -level;
618             }
619             code = get_rl_index(rl, last, run, level);
620             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
621             if (code == rl->n) {
622                 int level1, run1;
623
624                 level1 = level - rl->max_level[last][run];
625                 if (level1 < 1) 
626                     goto esc2;
627                 code = get_rl_index(rl, last, run, level1);
628                 if (code == rl->n) {
629                 esc2:
630                     put_bits(&s->pb, 1, 0);
631                     if (level > MAX_LEVEL)
632                         goto esc3;
633                     run1 = run - rl->max_run[last][level] - run_diff;
634                     if (run1 < 0)
635                         goto esc3;
636                     code = get_rl_index(rl, last, run1, level);
637                     if (code == rl->n) {
638                     esc3:
639                         /* third escape */
640                         put_bits(&s->pb, 1, 0);
641                         put_bits(&s->pb, 1, last);
642                         put_bits(&s->pb, 6, run);
643                         put_bits(&s->pb, 8, slevel & 0xff);
644                     } else {
645                         /* second escape */
646                         put_bits(&s->pb, 1, 1);
647                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
648                         put_bits(&s->pb, 1, sign);
649                     }
650                 } else {
651                     /* first escape */
652                     put_bits(&s->pb, 1, 1);
653                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
654                     put_bits(&s->pb, 1, sign);
655                 }
656             } else {
657                 put_bits(&s->pb, 1, sign);
658             }
659             last_non_zero = i;
660         }
661     }
662 }
663
664 /****************************************/
665 /* decoding stuff */
666
667 static VLC mb_non_intra_vlc;
668 static VLC mb_intra_vlc;
669 static VLC dc_lum_vlc[2];
670 static VLC dc_chroma_vlc[2];
671 static VLC v2_dc_lum_vlc;
672 static VLC v2_dc_chroma_vlc;
673 static VLC cbpy_vlc;
674 static VLC v2_intra_cbpc_vlc;
675 static VLC v2_mb_type_vlc;
676 static VLC v2_mv_vlc;
677
678 /* this table is practically identical to the one from h263 except that its inverted */
679 static void init_h263_dc_for_msmpeg4()
680 {
681     static int inited=0;
682     
683     if(!inited){
684         int level, uni_code, uni_len;
685         inited=1;
686
687         for(level=-256; level<256; level++){
688             int size, v, l;
689             /* find number of bits */
690             size = 0;
691             v = abs(level);
692             while (v) {
693                 v >>= 1;
694                     size++;
695             }
696
697             if (level < 0)
698                 l= (-level) ^ ((1 << size) - 1);
699             else
700                 l= level;
701
702             /* luminance h263 */
703             uni_code= DCtab_lum[size][0];
704             uni_len = DCtab_lum[size][1];
705             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
706
707             if (size > 0) {
708                 uni_code<<=size; uni_code|=l;
709                 uni_len+=size;
710                 if (size > 8){
711                     uni_code<<=1; uni_code|=1;
712                     uni_len++;
713                 }
714             }
715             v2_dc_lum_table[level+256][0]= uni_code;
716             v2_dc_lum_table[level+256][1]= uni_len;
717
718             /* chrominance h263 */
719             uni_code= DCtab_chrom[size][0];
720             uni_len = DCtab_chrom[size][1];
721             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
722             
723             if (size > 0) {
724                 uni_code<<=size; uni_code|=l;
725                 uni_len+=size;
726                 if (size > 8){
727                     uni_code<<=1; uni_code|=1;
728                     uni_len++;
729                 }
730             }
731             v2_dc_chroma_table[level+256][0]= uni_code;
732             v2_dc_chroma_table[level+256][1]= uni_len;
733
734         }
735     }
736 }
737
738 /* init all vlc decoding tables */
739 int msmpeg4_decode_init_vlc(MpegEncContext *s)
740 {
741     int i;
742     MVTable *mv;
743
744     for(i=0;i<NB_RL_TABLES;i++) {
745         init_rl(&rl_table[i]);
746         init_vlc_rl(&rl_table[i]);
747     }
748     for(i=0;i<2;i++) {
749         mv = &mv_tables[i];
750         init_vlc(&mv->vlc, 9, mv->n + 1, 
751                  mv->table_mv_bits, 1, 1,
752                  mv->table_mv_code, 2, 2);
753     }
754
755     init_vlc(&dc_lum_vlc[0], 9, 120, 
756              &table0_dc_lum[0][1], 8, 4,
757              &table0_dc_lum[0][0], 8, 4);
758     init_vlc(&dc_chroma_vlc[0], 9, 120, 
759              &table0_dc_chroma[0][1], 8, 4,
760              &table0_dc_chroma[0][0], 8, 4);
761     init_vlc(&dc_lum_vlc[1], 9, 120, 
762              &table1_dc_lum[0][1], 8, 4,
763              &table1_dc_lum[0][0], 8, 4);
764     init_vlc(&dc_chroma_vlc[1], 9, 120, 
765              &table1_dc_chroma[0][1], 8, 4,
766              &table1_dc_chroma[0][0], 8, 4);
767     
768     init_h263_dc_for_msmpeg4();
769     init_vlc(&v2_dc_lum_vlc, 9, 512, 
770              &v2_dc_lum_table[0][1], 8, 4,
771              &v2_dc_lum_table[0][0], 8, 4);
772     init_vlc(&v2_dc_chroma_vlc, 9, 512, 
773              &v2_dc_chroma_table[0][1], 8, 4,
774              &v2_dc_chroma_table[0][0], 8, 4);
775     
776     init_vlc(&cbpy_vlc, 6, 16,
777              &cbpy_tab[0][1], 2, 1,
778              &cbpy_tab[0][0], 2, 1);
779     init_vlc(&v2_intra_cbpc_vlc, 3, 4,
780              &v2_intra_cbpc[0][1], 2, 1,
781              &v2_intra_cbpc[0][0], 2, 1);
782     init_vlc(&v2_mb_type_vlc, 5, 8,
783              &v2_mb_type[0][1], 2, 1,
784              &v2_mb_type[0][0], 2, 1);
785     init_vlc(&v2_mv_vlc, 9, 33,
786              &mvtab[0][1], 2, 1,
787              &mvtab[0][0], 2, 1);
788
789     init_vlc(&mb_non_intra_vlc, 9, 128, 
790              &table_mb_non_intra[0][1], 8, 4,
791              &table_mb_non_intra[0][0], 8, 4);
792     init_vlc(&mb_intra_vlc, 9, 64, 
793              &table_mb_intra[0][1], 4, 2,
794              &table_mb_intra[0][0], 4, 2);
795     return 0;
796 }
797
798 static int decode012(GetBitContext *gb)
799 {
800     int n;
801     n = get_bits1(gb);
802     if (n == 0)
803         return 0;
804     else
805         return get_bits1(gb) + 1;
806 }
807
808 int msmpeg4_decode_picture_header(MpegEncContext * s)
809 {
810     int code, code2;
811
812 #if 0
813 {
814 int i;
815 for(i=0; i<s->gb.size*8; i++)
816     printf("%d", get_bits1(&s->gb));
817 //    get_bits1(&s->gb);
818 printf("END\n");
819 return -1;
820 }
821 #endif
822     s->pict_type = get_bits(&s->gb, 2) + 1;
823     if (s->pict_type != I_TYPE &&
824         s->pict_type != P_TYPE)
825         return -1;
826
827     s->qscale = get_bits(&s->gb, 5);
828
829     if (s->pict_type == I_TYPE) {
830         code = get_bits(&s->gb, 5); 
831         /* 0x17: one slice, 0x18: two slices */
832         if (code < 0x17)
833             return -1;
834         s->slice_height = s->mb_height / (code - 0x16);
835
836         switch(s->msmpeg4_version){
837         case 2:
838             s->rl_chroma_table_index = 2;
839             s->rl_table_index = 2;
840
841             s->dc_table_index = 0; //not used
842             break;
843         case 3:
844             s->rl_chroma_table_index = decode012(&s->gb);
845             s->rl_table_index = decode012(&s->gb);
846
847             s->dc_table_index = get_bits1(&s->gb);
848             break;
849         case 4:
850             msmpeg4_decode_ext_header(s, 999 /* bufer size (useless here) */);
851             printf("%X\n", show_bits(&s->gb, 24));
852             code= get_bits(&s->gb, 2);
853             if(code==1){
854                 code2= get_bits(&s->gb, 3);
855                 if(code2==7) skip_bits(&s->gb, 1);
856             }
857             printf("%X\n", show_bits(&s->gb, 24));
858             s->rl_chroma_table_index = 2;
859             s->rl_table_index = 2;
860
861             s->dc_table_index = 0;
862             break;
863         }
864         s->no_rounding = 1;
865 /*      printf(" %d %d %d %d     \n", 
866                 s->qscale,
867                 s->rl_chroma_table_index,
868                 s->rl_table_index, 
869                 s->dc_table_index);*/
870     } else {
871         s->use_skip_mb_code = get_bits1(&s->gb);
872         
873         if(s->msmpeg4_version==2){
874             s->rl_table_index = 2;
875             s->rl_chroma_table_index = s->rl_table_index;
876
877             s->dc_table_index = 0; //not used
878
879             s->mv_table_index = 0;
880         }else{
881             s->rl_table_index = decode012(&s->gb);
882             s->rl_chroma_table_index = s->rl_table_index;
883
884             s->dc_table_index = get_bits1(&s->gb);
885
886             s->mv_table_index = get_bits1(&s->gb);
887         }
888 /*      printf(" %d %d %d %d %d     \n", 
889                 s->use_skip_mb_code, 
890                 s->rl_table_index, 
891                 s->rl_chroma_table_index, 
892                 s->dc_table_index,
893                 s->mv_table_index);*/
894         if(s->flipflop_rounding){
895             s->no_rounding ^= 1;
896         }else{
897             s->no_rounding = 0;
898         }
899 //      printf("%d", s->no_rounding);
900 //return -1;
901     }
902     
903 #if 0
904 if(s->msmpeg4_version==2)
905 {
906 int i;
907 for(i=0; i<s->gb.size*8; i++)
908 //    printf("%d", get_bits1(&s->gb));
909     get_bits1(&s->gb);
910 printf("END\n");
911 return -1;
912 }
913 #endif
914
915 #ifdef DEBUG
916     printf("*****frame %d:\n", frame_count++);
917 #endif
918     return 0;
919 }
920
921 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
922 {
923     /* the alt_bitstream reader could read over the end so we need to check it */
924     if(get_bits_count(&s->gb) + 16 < buf_size*8)
925     {
926         int fps;
927
928         fps= get_bits(&s->gb, 5);
929         s->bitrate= get_bits(&s->gb, 11);
930         s->flipflop_rounding= get_bits1(&s->gb);
931
932 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bitrate, s->flipflop_rounding);
933     }
934     else
935     {
936         s->flipflop_rounding= 0;
937         s->bitrate= 0;
938     }
939
940     return 0;
941 }
942
943 static inline void memsetw(short *tab, int val, int n)
944 {
945     int i;
946     for(i=0;i<n;i++)
947         tab[i] = val;
948 }
949
950 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
951 {
952     int range, bit_size, sign, code, bits;
953
954     if (val == 0) {
955         /* zero vector */
956         code = 0;
957         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
958     } else {
959         bit_size = s->f_code - 1;
960         range = 1 << bit_size;
961         if (val <= -64)
962             val += 64;
963         else if (val >= 64)
964             val -= 64;
965
966         if (val >= 0) {
967             sign = 0;
968         } else {
969             val = -val;
970             sign = 1;
971         }
972         val--;
973         code = (val >> bit_size) + 1;
974         bits = val & (range - 1);
975
976         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
977         if (bit_size > 0) {
978             put_bits(&s->pb, bit_size, bits);
979         }
980     }
981 }
982
983 /* this is identical to h263 except that its range is multiplied by 2 */
984 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
985 {
986     int code, val, sign, shift;
987
988     code = get_vlc(&s->gb, &v2_mv_vlc);
989     if (code < 0)
990         return 0xffff;
991
992     if (code == 0)
993         return pred;
994     sign = get_bits1(&s->gb);
995     shift = f_code - 1;
996     val = (code - 1) << shift;
997     if (shift > 0)
998         val |= get_bits(&s->gb, shift);
999     val++;
1000     if (sign)
1001         val = -val;
1002     val += pred;
1003
1004     if (val <= -64)
1005         val += 64;
1006     else if (val >= 64)
1007         val -= 64;
1008
1009     return val;
1010 }
1011
1012
1013 int msmpeg4v2_decode_mb(MpegEncContext *s, 
1014                       DCTELEM block[6][64])
1015 {
1016     int cbp, code, i;
1017     if (s->pict_type == P_TYPE) {
1018         if (s->use_skip_mb_code) {
1019             if (get_bits1(&s->gb)) {
1020                 /* skip mb */
1021                 s->mb_intra = 0;
1022                 for(i=0;i<6;i++)
1023                     s->block_last_index[i] = -1;
1024                 s->mv_dir = MV_DIR_FORWARD;
1025                 s->mv_type = MV_TYPE_16X16;
1026                 s->mv[0][0][0] = 0;
1027                 s->mv[0][0][1] = 0;
1028                 s->mb_skiped = 1;
1029                 return 0;
1030             }
1031         }
1032
1033         code = get_vlc(&s->gb, &v2_mb_type_vlc);
1034         s->mb_intra = code >>2;
1035     
1036         cbp = code & 0x3;
1037     } else {
1038         s->mb_intra = 1;
1039         cbp= get_vlc(&s->gb, &v2_intra_cbpc_vlc);
1040     }
1041
1042     if (!s->mb_intra) {
1043         int mx, my;
1044
1045         cbp|= get_vlc(&s->gb, &cbpy_vlc)<<2;
1046         if((cbp&3) != 3) cbp^= 0x3C;
1047         
1048         h263_pred_motion(s, 0, &mx, &my);
1049         mx= msmpeg4v2_decode_motion(s, mx, 1);
1050         my= msmpeg4v2_decode_motion(s, my, 1);
1051         
1052         s->mv_dir = MV_DIR_FORWARD;
1053         s->mv_type = MV_TYPE_16X16;
1054         s->mv[0][0][0] = mx;
1055         s->mv[0][0][1] = my;
1056     } else {
1057         s->ac_pred = get_bits1(&s->gb);
1058         cbp|= get_vlc(&s->gb, &cbpy_vlc)<<2;
1059     }
1060
1061     for (i = 0; i < 6; i++) {
1062         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1063         {
1064              fprintf(stderr,"\nIgnoring error while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1065              return -1;
1066         }
1067     }
1068     return 0;
1069 }
1070
1071 int msmpeg4_decode_mb(MpegEncContext *s, 
1072                       DCTELEM block[6][64])
1073 {
1074     int cbp, code, i;
1075     UINT8 *coded_val;
1076
1077     /* special slice handling */
1078     if (s->mb_x == 0) {
1079         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
1080             int wrap;
1081             /* reset DC pred (set previous line to 1024) */
1082             wrap = 2 * s->mb_width + 2;
1083             memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap], 
1084                     1024, 2 * s->mb_width);
1085             wrap = s->mb_width + 2;
1086             memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap], 
1087                     1024, s->mb_width);
1088             memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap], 
1089                     1024, s->mb_width);
1090             
1091             /* reset AC pred (set previous line to 0) */
1092             wrap = s->mb_width * 2 + 2;
1093             memsetw(s->ac_val[0][0] + (1 + (2 * s->mb_y) * wrap)*16,
1094                     0, 2 * s->mb_width*16);
1095             wrap = s->mb_width + 2;
1096             memsetw(s->ac_val[1][0] + (1 + (s->mb_y) * wrap)*16,
1097                     0, s->mb_width*16);
1098             memsetw(s->ac_val[2][0] + (1 + (s->mb_y) * wrap)*16,
1099                     0, s->mb_width*16);
1100
1101             s->first_slice_line = 1;
1102         } else {
1103             s->first_slice_line = 0; 
1104         }
1105     }
1106
1107     if(s->msmpeg4_version==2) return msmpeg4v2_decode_mb(s, block); //FIXME merge if possible
1108     
1109     if (s->pict_type == P_TYPE) {
1110         set_stat(ST_INTER_MB);
1111         if (s->use_skip_mb_code) {
1112             if (get_bits1(&s->gb)) {
1113                 /* skip mb */
1114                 s->mb_intra = 0;
1115                 for(i=0;i<6;i++)
1116                     s->block_last_index[i] = -1;
1117                 s->mv_dir = MV_DIR_FORWARD;
1118                 s->mv_type = MV_TYPE_16X16;
1119                 s->mv[0][0][0] = 0;
1120                 s->mv[0][0][1] = 0;
1121                 s->mb_skiped = 1;
1122                 return 0;
1123             }
1124         }
1125         
1126         code = get_vlc(&s->gb, &mb_non_intra_vlc);
1127         if (code < 0)
1128             return -1;
1129         //s->mb_intra = (code & 0x40) ? 0 : 1;
1130         s->mb_intra = (~code & 0x40) >> 6;
1131             
1132         cbp = code & 0x3f;
1133     } else {
1134         set_stat(ST_INTRA_MB);
1135         s->mb_intra = 1;
1136         code = get_vlc(&s->gb, &mb_intra_vlc);
1137         if (code < 0)
1138             return -1;
1139         /* predict coded block pattern */
1140         cbp = 0;
1141         for(i=0;i<6;i++) {
1142             int val = ((code >> (5 - i)) & 1);
1143             if (i < 4) {
1144                 int pred = coded_block_pred(s, i, &coded_val);
1145                 val = val ^ pred;
1146                 *coded_val = val;
1147             }
1148             cbp |= val << (5 - i);
1149         }
1150     }
1151
1152     if (!s->mb_intra) {
1153         int mx, my;
1154         set_stat(ST_MV);
1155         h263_pred_motion(s, 0, &mx, &my);
1156         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1157             return -1;
1158         s->mv_dir = MV_DIR_FORWARD;
1159         s->mv_type = MV_TYPE_16X16;
1160         s->mv[0][0][0] = mx;
1161         s->mv[0][0][1] = my;
1162     } else {
1163         set_stat(ST_INTRA_MB);
1164         s->ac_pred = get_bits1(&s->gb);
1165     }
1166
1167     for (i = 0; i < 6; i++) {
1168         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1169         {
1170             fprintf(stderr,"\nIgnoring error while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1171             // return -1;
1172         }
1173     }
1174     return 0;
1175 }
1176
1177 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1178                               int n, int coded)
1179 {
1180     int code, level, i, j, last, run, run_diff;
1181     int dc_pred_dir;
1182     RLTable *rl;
1183     const UINT8 *scan_table;
1184     int qmul, qadd;
1185
1186     if (s->mb_intra) {
1187         qmul=1;
1188         qadd=0;
1189
1190         /* DC coef */
1191         set_stat(ST_DC);
1192         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1193         if (level < 0)
1194             return -1;
1195         block[0] = level;
1196         if (n < 4) {
1197             rl = &rl_table[s->rl_table_index];
1198         } else {
1199             rl = &rl_table[3 + s->rl_chroma_table_index];
1200         }
1201
1202         run_diff = 0;
1203         i = 1;
1204         if (!coded) {
1205             goto not_coded;
1206         }
1207         if (s->ac_pred) {
1208             if (dc_pred_dir == 0) 
1209                 scan_table = ff_alternate_vertical_scan; /* left */
1210             else
1211                 scan_table = ff_alternate_horizontal_scan; /* top */
1212         } else {
1213             scan_table = zigzag_direct;
1214         }
1215         set_stat(ST_INTRA_AC);
1216     } else {
1217         qmul = s->qscale << 1;
1218         qadd = (s->qscale - 1) | 1;
1219         i = 0;
1220         rl = &rl_table[3 + s->rl_table_index];
1221
1222         if(s->msmpeg4_version==2)
1223             run_diff = 0;
1224         else
1225             run_diff = 1;
1226
1227         if (!coded) {
1228             s->block_last_index[n] = i - 1;
1229             return 0;
1230         }
1231         scan_table = zigzag_direct;
1232         set_stat(ST_INTER_AC);
1233     }
1234
1235     for(;;) {
1236         code = get_vlc(&s->gb, &rl->vlc);
1237         if (code < 0)
1238             return -1;
1239         if (code == rl->n) {
1240             /* escape */
1241             if (get_bits1(&s->gb) == 0) {
1242                 if (get_bits1(&s->gb) == 0) {
1243                     /* third escape */
1244                     last = get_bits1(&s->gb);
1245                     run = get_bits(&s->gb, 6);
1246                     level = get_bits(&s->gb, 8);
1247                     level = (level << 24) >> 24; /* sign extend */
1248                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1249                     if (level>0) level= level * qmul + qadd;
1250                     else        level= level * qmul - qadd;
1251                 } else {
1252                     /* second escape */
1253                     code = get_vlc(&s->gb, &rl->vlc);
1254                     if (code < 0 || code >= rl->n)
1255                         return -1;
1256                     run = rl->table_run[code];
1257                     level = rl->table_level[code];
1258                     last = code >= rl->last;
1259                     run += rl->max_run[last][level] + run_diff;
1260                     level= level * qmul + qadd;
1261                     if (get_bits1(&s->gb))
1262                         level = -level;
1263                 }
1264             } else {
1265                 /* first escape */
1266                 code = get_vlc(&s->gb, &rl->vlc);
1267                 if (code < 0 || code >= rl->n)
1268                     return -1;
1269                 run = rl->table_run[code];
1270                 level = rl->table_level[code];
1271                 last = code >= rl->last;
1272                 level += rl->max_level[last][run];
1273                 level= level * qmul + qadd;
1274                 if (get_bits1(&s->gb))
1275                     level = -level;
1276             }
1277         } else {
1278             run = rl->table_run[code];
1279             level = rl->table_level[code] * qmul + qadd;
1280             last = code >= rl->last;
1281             if (get_bits1(&s->gb))
1282                 level = -level;
1283         }
1284         i += run;
1285         if (i >= 64)
1286             return -1;
1287 //printf("RL:%d %d %d ", run, level, last);
1288         j = scan_table[i];
1289         block[j] = level;
1290         i++;
1291         if (last)
1292             break;
1293     }
1294  not_coded:
1295     if (s->mb_intra) {
1296         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1297         if (s->ac_pred) {
1298             i = 64; /* XXX: not optimal */
1299         }
1300     }
1301     s->block_last_index[n] = i - 1;
1302
1303     return 0;
1304 }
1305
1306 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1307 {
1308     int level, pred;
1309     INT16 *dc_val;
1310
1311     if(s->msmpeg4_version==2){
1312         if (n < 4) {
1313             level = get_vlc(&s->gb, &v2_dc_lum_vlc);
1314         } else {
1315             level = get_vlc(&s->gb, &v2_dc_chroma_vlc);
1316         }
1317         if (level < 0) 
1318             return -1;
1319         level-=256;
1320     }else{  //FIXME optimize use unified tables & index
1321         if (n < 4) {
1322             level = get_vlc(&s->gb, &dc_lum_vlc[s->dc_table_index]);
1323         } else {
1324             level = get_vlc(&s->gb, &dc_chroma_vlc[s->dc_table_index]);
1325         }
1326         if (level < 0)
1327             return -1;
1328
1329         if (level == DC_MAX) {
1330             level = get_bits(&s->gb, 8);
1331             if (get_bits1(&s->gb))
1332                 level = -level;
1333         } else if (level != 0) {
1334             if (get_bits1(&s->gb))
1335                 level = -level;
1336         }
1337     }
1338
1339     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1340     level += pred;
1341
1342     /* update predictor */
1343     if (n < 4) {
1344         *dc_val = level * s->y_dc_scale;
1345     } else {
1346         *dc_val = level * s->c_dc_scale;
1347     }
1348
1349     return level;
1350 }
1351
1352 static int msmpeg4_decode_motion(MpegEncContext * s, 
1353                                  int *mx_ptr, int *my_ptr)
1354 {
1355     MVTable *mv;
1356     int code, mx, my;
1357
1358     mv = &mv_tables[s->mv_table_index];
1359
1360     code = get_vlc(&s->gb, &mv->vlc);
1361     if (code < 0)
1362         return -1;
1363     if (code == mv->n) {
1364         mx = get_bits(&s->gb, 6);
1365         my = get_bits(&s->gb, 6);
1366     } else {
1367         mx = mv->table_mvx[code];
1368         my = mv->table_mvy[code];
1369     }
1370
1371     mx += *mx_ptr - 32;
1372     my += *my_ptr - 32;
1373     /* WARNING : they do not do exactly modulo encoding */
1374     if (mx <= -64)
1375         mx += 64;
1376     else if (mx >= 64)
1377         mx -= 64;
1378
1379     if (my <= -64)
1380         my += 64;
1381     else if (my >= 64)
1382         my -= 64;
1383     *mx_ptr = mx;
1384     *my_ptr = my;
1385     return 0;
1386 }