(commit by michael)
[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
25 /*
26  * You can also call this codec : MPEG4 with a twist ! 
27  *
28  * TODO: 
29  *        - (encoding) select best mv table (two choices)
30  *        - (encoding) select best vlc/dc table 
31  *        - (decoding) handle slice indication
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 void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
47 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
48                                 int n, int coded);
49 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
50 static int msmpeg4_decode_motion(MpegEncContext * s, 
51                                  int *mx_ptr, int *my_ptr);
52
53 #ifdef DEBUG
54 int intra_count = 0;
55 int frame_count = 0;
56 #endif
57 /* XXX: move it to mpegvideo.h */
58
59 static int init_done = 0;
60
61 #include "msmpeg4data.h"
62
63 #ifdef STATS
64
65 const char *st_names[ST_NB] = {
66     "unknown",
67     "dc",
68     "intra_ac",
69     "inter_ac",
70     "intra_mb",
71     "inter_mb",
72     "mv",
73 };
74
75 int st_current_index = 0;
76 unsigned int st_bit_counts[ST_NB];
77 unsigned int st_out_bit_counts[ST_NB];
78
79 #define set_stat(var) st_current_index = var;
80
81 void print_stats(void)
82 {
83     unsigned int total;
84     int i;
85
86     printf("Input:\n");
87     total = 0;
88     for(i=0;i<ST_NB;i++)
89         total += st_bit_counts[i];
90     if (total == 0)
91         total = 1;
92     for(i=0;i<ST_NB;i++) {
93         printf("%-10s : %10.1f %5.1f%%\n", 
94                st_names[i], 
95                (double)st_bit_counts[i] / 8.0, 
96                (double)st_bit_counts[i] * 100.0 / total);
97     }
98     printf("%-10s : %10.1f %5.1f%%\n",
99            "total", 
100            (double)total / 8.0, 
101            100.0);
102
103     printf("Output:\n");
104     total = 0;
105     for(i=0;i<ST_NB;i++)
106         total += st_out_bit_counts[i];
107     if (total == 0)
108         total = 1;
109     for(i=0;i<ST_NB;i++) {
110         printf("%-10s : %10.1f %5.1f%%\n", 
111                st_names[i], 
112                (double)st_out_bit_counts[i] / 8.0, 
113                (double)st_out_bit_counts[i] * 100.0 / total);
114     }
115     printf("%-10s : %10.1f %5.1f%%\n",
116            "total", 
117            (double)total / 8.0, 
118            100.0);
119 }
120
121 #else
122
123 #define set_stat(var)
124
125 #endif
126
127 /* build the table which associate a (x,y) motion vector to a vlc */
128 static void init_mv_table(MVTable *tab)
129 {
130     int i, x, y;
131
132     tab->table_mv_index = malloc(sizeof(UINT16) * 4096);
133     /* mark all entries as not used */
134     for(i=0;i<4096;i++)
135         tab->table_mv_index[i] = tab->n;
136     
137     for(i=0;i<tab->n;i++) {
138         x = tab->table_mvx[i];
139         y = tab->table_mvy[i];
140         tab->table_mv_index[(x << 6) | y] = i;
141     }
142 }
143
144 static void code012(PutBitContext *pb, int n)
145 {
146     if (n == 0) {
147         put_bits(pb, 1, 0);
148     } else {
149         put_bits(pb, 1, 1);
150         put_bits(pb, 1, (n >= 2));
151     }
152 }
153
154 /* write MSMPEG4 V3 compatible frame header */
155 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
156 {
157     int i;
158
159     align_put_bits(&s->pb);
160
161     put_bits(&s->pb, 2, s->pict_type - 1);
162
163     put_bits(&s->pb, 5, s->qscale);
164
165     s->rl_table_index = 2;
166     s->rl_chroma_table_index = 1; /* only for I frame */
167     s->dc_table_index = 1;
168     s->mv_table_index = 1; /* only if P frame */
169     s->use_skip_mb_code = 1; /* only if P frame */
170     
171     if (s->pict_type == I_TYPE) {
172         put_bits(&s->pb, 5, 0x17); /* indicate only one "slice" */
173
174         code012(&s->pb, s->rl_chroma_table_index);
175         code012(&s->pb, s->rl_table_index);
176
177         put_bits(&s->pb, 1, s->dc_table_index);
178         s->no_rounding = 1;
179     } else {
180         put_bits(&s->pb, 1, s->use_skip_mb_code);
181         
182         s->rl_chroma_table_index = s->rl_table_index;
183         code012(&s->pb, s->rl_table_index);
184
185         put_bits(&s->pb, 1, s->dc_table_index);
186
187         put_bits(&s->pb, 1, s->mv_table_index);
188         s->no_rounding ^= 1;
189     }
190
191     if (!init_done) {
192         /* init various encoding tables */
193         init_done = 1;
194         init_mv_table(&mv_tables[0]);
195         init_mv_table(&mv_tables[1]);
196         for(i=0;i<NB_RL_TABLES;i++)
197             init_rl(&rl_table[i]);
198     }
199
200 #ifdef DEBUG
201     intra_count = 0;
202     printf("*****frame %d:\n", frame_count++);
203 #endif
204 }
205
206 /* predict coded block */
207 static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
208 {
209     int x, y, wrap, pred, a, b, c;
210
211     x = 2 * s->mb_x + 1 + (n & 1);
212     y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
213     wrap = s->mb_width * 2 + 2;
214
215     /* B C
216      * A X 
217      */
218     a = s->coded_block[(x - 1) + (y) * wrap];
219     b = s->coded_block[(x - 1) + (y - 1) * wrap];
220     c = s->coded_block[(x) + (y - 1) * wrap];
221     
222     if (b == c) {
223         pred = a;
224     } else {
225         pred = c;
226     }
227     
228     /* store value */
229     *coded_block_ptr = &s->coded_block[(x) + (y) * wrap];
230
231     return pred;
232 }
233
234 static void msmpeg4_encode_motion(MpegEncContext * s, 
235                                   int mx, int my)
236 {
237     int code;
238     MVTable *mv;
239
240     /* modulo encoding */
241     /* WARNING : you cannot reach all the MVs even with the modulo
242        encoding. This is a somewhat strange compromise they took !!!  */
243     if (mx <= -64)
244         mx += 64;
245     else if (mx >= 64)
246         mx -= 64;
247     if (my <= -64)
248         my += 64;
249     else if (my >= 64)
250         my -= 64;
251     
252     mx += 32;
253     my += 32;
254 #if 0
255     if ((unsigned)mx >= 64 ||
256         (unsigned)my >= 64) 
257         fprintf(stderr, "error mx=%d my=%d\n", mx, my);
258 #endif
259     mv = &mv_tables[s->mv_table_index];
260
261     code = mv->table_mv_index[(mx << 6) | my];
262     set_stat(ST_MV);
263     put_bits(&s->pb, 
264              mv->table_mv_bits[code], 
265              mv->table_mv_code[code]);
266     if (code == mv->n) {
267         /* escape : code litterally */
268         put_bits(&s->pb, 6, mx);
269         put_bits(&s->pb, 6, my);
270     }
271 }
272
273 void msmpeg4_encode_mb(MpegEncContext * s, 
274                        DCTELEM block[6][64],
275                        int motion_x, int motion_y)
276 {
277     int cbp, coded_cbp, i;
278     int pred_x, pred_y;
279     UINT8 *coded_block;
280
281     if (!s->mb_intra) {
282         /* compute cbp */
283         set_stat(ST_INTER_MB);
284         cbp = 0;
285         for (i = 0; i < 6; i++) {
286             if (s->block_last_index[i] >= 0)
287                 cbp |= 1 << (5 - i);
288         }
289         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
290             /* skip macroblock */
291             put_bits(&s->pb, 1, 1);
292             return;
293         }
294         if (s->use_skip_mb_code)
295             put_bits(&s->pb, 1, 0);     /* mb coded */
296         
297         put_bits(&s->pb, 
298                  table_mb_non_intra[cbp + 64][1], 
299                  table_mb_non_intra[cbp + 64][0]);
300
301         /* motion vector */
302         h263_pred_motion(s, 0, &pred_x, &pred_y);
303         msmpeg4_encode_motion(s, motion_x - pred_x, 
304                               motion_y - pred_y);
305     } else {
306         /* compute cbp */
307         cbp = 0;
308         coded_cbp = 0;
309         for (i = 0; i < 6; i++) {
310             int val, pred;
311             val = (s->block_last_index[i] >= 1);
312             cbp |= val << (5 - i);
313             if (i < 4) {
314                 /* predict value for close blocks only for luma */
315                 pred = coded_block_pred(s, i, &coded_block);
316                 *coded_block = val;
317                 val = val ^ pred;
318             }
319             coded_cbp |= val << (5 - i);
320         }
321 #if 0
322         if (coded_cbp)
323             printf("cbp=%x %x\n", cbp, coded_cbp);
324 #endif
325
326         if (s->pict_type == I_TYPE) {
327             set_stat(ST_INTRA_MB);
328             put_bits(&s->pb, 
329                      table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
330         } else {
331             if (s->use_skip_mb_code)
332                 put_bits(&s->pb, 1, 0); /* mb coded */
333             put_bits(&s->pb, 
334                      table_mb_non_intra[cbp][1], 
335                      table_mb_non_intra[cbp][0]);
336         }
337         set_stat(ST_INTRA_MB);
338         put_bits(&s->pb, 1, 0); /* no AC prediction yet */
339     }
340
341     for (i = 0; i < 6; i++) {
342         msmpeg4_encode_block(s, block[i], i);
343     }
344 }
345
346
347 /* strongly inspirated from MPEG4, but not exactly the same ! */
348 void msmpeg4_dc_scale(MpegEncContext * s)
349 {
350     if (s->qscale < 5){
351         s->y_dc_scale = 8;
352         s->c_dc_scale = 8;
353 //        s->c_dc_scale = (s->qscale + 13)>>1;
354     }else if (s->qscale < 9){
355         s->y_dc_scale = 2 * s->qscale;
356         s->c_dc_scale = (s->qscale + 13)>>1;
357     }else{
358         s->y_dc_scale = s->qscale + 8;
359         s->c_dc_scale = (s->qscale + 13)>>1;
360     }
361     // this differs for quant >24 from mpeg4 
362     
363 //    if(s->qscale==13) s->c_dc_scale=14;
364     
365 //    if(s->qscale>=6)
366 //     printf("%d", s->qscale);
367     
368     /* s->c_dc_scale values (found by Michael Nidermayer)
369      qscale=2 -> 8 (yes iam sure about that)
370      qscale=3 -> 8
371      qscale=4 -> 8
372      qscale=5 -> 9
373      qscale=6 -> 9 
374      qscale=7 -> 10
375      qscale=8 -> 10
376      qscale=9 -> 11
377      qscale=10-> 11
378     */
379 }
380
381 /* dir = 0: left, dir = 1: top prediction */
382 static int msmpeg4_pred_dc(MpegEncContext * s, int n, 
383                            INT16 **dc_val_ptr, int *dir_ptr)
384 {
385     int a, b, c, x, y, wrap, pred, scale;
386     INT16 *dc_val;
387
388     /* find prediction */
389     if (n < 4) {
390         x = 2 * s->mb_x + 1 + (n & 1);
391         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
392         wrap = s->mb_width * 2 + 2;
393         dc_val = s->dc_val[0];
394         scale = s->y_dc_scale;
395     } else {
396         x = s->mb_x + 1;
397         y = s->mb_y + 1;
398         wrap = s->mb_width + 2;
399         dc_val = s->dc_val[n - 4 + 1];
400         scale = s->c_dc_scale;
401     }
402
403     /* B C
404      * A X 
405      */
406     a = dc_val[(x - 1) + (y) * wrap];
407     b = dc_val[(x - 1) + (y - 1) * wrap];
408     c = dc_val[(x) + (y - 1) * wrap];
409
410     /* XXX: the following solution consumes divisions, but it does not
411        necessitate to modify mpegvideo.c. The problem comes from the
412        fact they decided to store the quantized DC (which would lead
413        to problems if Q could vary !) */
414     a = (a + (scale >> 1)) / scale;
415     b = (b + (scale >> 1)) / scale;
416     c = (c + (scale >> 1)) / scale;
417
418     /* XXX: WARNING: they did not choose the same test as MPEG4. This
419        is very important ! */
420     if (abs(a - b) <= abs(b - c)) {
421         pred = c;
422         *dir_ptr = 1;
423     } else {
424         pred = a;
425         *dir_ptr = 0;
426     }
427
428     /* update predictor */
429     *dc_val_ptr = &dc_val[(x) + (y) * wrap];
430     return pred;
431 }
432
433 #define DC_MAX 119
434
435 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
436 {
437     int sign, code;
438     int pred;
439     INT16 *dc_val;
440
441     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
442
443     /* update predictor */
444     if (n < 4) {
445         *dc_val = level * s->y_dc_scale;
446     } else {
447         *dc_val = level * s->c_dc_scale;
448     }
449
450     /* do the prediction */
451     level -= pred;
452
453     sign = 0;
454     if (level < 0) {
455         level = -level;
456         sign = 1;
457     }
458     
459     code = level;
460     if (code > DC_MAX) 
461         code = DC_MAX;
462
463     if (s->dc_table_index == 0) {
464         if (n < 4) {
465             put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
466         } else {
467             put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
468         }
469     } else {
470         if (n < 4) {
471             put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
472         } else {
473             put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
474         }
475     }
476         
477     if (code == DC_MAX)
478         put_bits(&s->pb, 8, level);
479         
480     if (level != 0) {
481         put_bits(&s->pb, 1, sign);
482     }
483 }
484
485 /* Encoding of a block. Very similar to MPEG4 except for a different
486    escape coding (same as H263) and more vlc tables.
487  */
488 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
489 {
490     int level, run, last, i, j, last_index;
491     int last_non_zero, sign, slevel;
492     int code, run_diff, dc_pred_dir;
493     const RLTable *rl;
494
495     if (s->mb_intra) {
496         set_stat(ST_DC);
497         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
498         i = 1;
499         if (n < 4) {
500             rl = &rl_table[s->rl_table_index];
501         } else {
502             rl = &rl_table[3 + s->rl_chroma_table_index];
503         }
504         run_diff = 0;
505         set_stat(ST_INTRA_AC);
506     } else {
507         i = 0;
508         rl = &rl_table[3 + s->rl_table_index];
509         run_diff = 1;
510         set_stat(ST_INTER_AC);
511     }
512
513     /* AC coefs */
514     last_index = s->block_last_index[n];
515     last_non_zero = i - 1;
516     for (; i <= last_index; i++) {
517         j = zigzag_direct[i];
518         level = block[j];
519         if (level) {
520             run = i - last_non_zero - 1;
521             last = (i == last_index);
522             sign = 0;
523             slevel = level;
524             if (level < 0) {
525                 sign = 1;
526                 level = -level;
527             }
528             code = get_rl_index(rl, last, run, level);
529             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
530             if (code == rl->n) {
531                 int level1, run1;
532
533                 level1 = level - rl->max_level[last][run];
534                 if (level1 < 1) 
535                     goto esc2;
536                 code = get_rl_index(rl, last, run, level1);
537                 if (code == rl->n) {
538                 esc2:
539                     put_bits(&s->pb, 1, 0);
540                     if (level > MAX_LEVEL)
541                         goto esc3;
542                     run1 = run - rl->max_run[last][level] - run_diff;
543                     if (run1 < 0)
544                         goto esc3;
545                     code = get_rl_index(rl, last, run1, level);
546                     if (code == rl->n) {
547                     esc3:
548                         /* third escape */
549                         put_bits(&s->pb, 1, 0);
550                         put_bits(&s->pb, 1, last);
551                         put_bits(&s->pb, 6, run);
552                         put_bits(&s->pb, 8, slevel & 0xff);
553                     } else {
554                         /* second escape */
555                         put_bits(&s->pb, 1, 1);
556                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
557                         put_bits(&s->pb, 1, sign);
558                     }
559                 } else {
560                     /* first escape */
561                     put_bits(&s->pb, 1, 1);
562                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
563                     put_bits(&s->pb, 1, sign);
564                 }
565             } else {
566                 put_bits(&s->pb, 1, sign);
567             }
568             last_non_zero = i;
569         }
570     }
571 }
572
573 /****************************************/
574 /* decoding stuff */
575
576 static VLC mb_non_intra_vlc;
577 static VLC mb_intra_vlc;
578 static VLC dc_lum_vlc[2];
579 static VLC dc_chroma_vlc[2];
580
581 /* init all vlc decoding tables */
582 int msmpeg4_decode_init_vlc(MpegEncContext *s)
583 {
584     int i;
585     MVTable *mv;
586
587     for(i=0;i<NB_RL_TABLES;i++) {
588         init_rl(&rl_table[i]);
589         init_vlc_rl(&rl_table[i]);
590     }
591     for(i=0;i<2;i++) {
592         mv = &mv_tables[i];
593         init_vlc(&mv->vlc, 9, mv->n + 1, 
594                  mv->table_mv_bits, 1, 1,
595                  mv->table_mv_code, 2, 2);
596     }
597
598     init_vlc(&dc_lum_vlc[0], 9, 120, 
599              &table0_dc_lum[0][1], 8, 4,
600              &table0_dc_lum[0][0], 8, 4);
601     init_vlc(&dc_chroma_vlc[0], 9, 120, 
602              &table0_dc_chroma[0][1], 8, 4,
603              &table0_dc_chroma[0][0], 8, 4);
604     init_vlc(&dc_lum_vlc[1], 9, 120, 
605              &table1_dc_lum[0][1], 8, 4,
606              &table1_dc_lum[0][0], 8, 4);
607     init_vlc(&dc_chroma_vlc[1], 9, 120, 
608              &table1_dc_chroma[0][1], 8, 4,
609              &table1_dc_chroma[0][0], 8, 4);
610
611     init_vlc(&mb_non_intra_vlc, 9, 128, 
612              &table_mb_non_intra[0][1], 8, 4,
613              &table_mb_non_intra[0][0], 8, 4);
614     init_vlc(&mb_intra_vlc, 9, 64, 
615              &table_mb_intra[0][1], 4, 2,
616              &table_mb_intra[0][0], 4, 2);
617     return 0;
618 }
619
620 static int decode012(GetBitContext *gb)
621 {
622     int n;
623     n = get_bits1(gb);
624     if (n == 0)
625         return 0;
626     else
627         return get_bits1(gb) + 1;
628 }
629
630 int msmpeg4_decode_picture_header(MpegEncContext * s)
631 {
632     int code;
633 static int weirdAl=0;
634
635     s->pict_type = get_bits(&s->gb, 2) + 1;
636     if (s->pict_type != I_TYPE &&
637         s->pict_type != P_TYPE)
638         return -1;
639
640     s->qscale = get_bits(&s->gb, 5);
641
642     if (s->pict_type == I_TYPE) {
643         code = get_bits(&s->gb, 5); 
644         /* 0x17: one slice, 0x18: three slices */
645         /* XXX: implement it */
646         //printf("%d %d %d\n", code, s->slice_height, s->first_slice_line);
647         if (code < 0x17)
648             return -1;
649         s->slice_height = s->mb_height / (code - 0x16);
650         s->rl_chroma_table_index = decode012(&s->gb);
651         s->rl_table_index = decode012(&s->gb);
652
653         s->dc_table_index = get_bits1(&s->gb);
654         s->no_rounding = 1;
655 /*      printf(" %d %d %d %d     \n", 
656                 s->qscale,
657                 s->rl_chroma_table_index,
658                 s->rl_table_index, 
659                 s->dc_table_index);*/
660     } else {
661         s->use_skip_mb_code = get_bits1(&s->gb);
662         
663         s->rl_table_index = decode012(&s->gb);
664         s->rl_chroma_table_index = s->rl_table_index;
665
666         s->dc_table_index = get_bits1(&s->gb);
667
668         s->mv_table_index = get_bits1(&s->gb);
669 /*      printf(" %d %d %d %d %d     \n", 
670                 s->use_skip_mb_code, 
671                 s->rl_table_index, 
672                 s->rl_chroma_table_index, 
673                 s->dc_table_index,
674                 s->mv_table_index);*/
675   if(weirdAl)
676         s->no_rounding = 0;
677   else
678         s->no_rounding ^= 1;
679     }
680 #ifdef DEBUG
681     printf("*****frame %d:\n", frame_count++);
682 #endif
683     return 0;
684 }
685
686 void memsetw(short *tab, int val, int n)
687 {
688     int i;
689     for(i=0;i<n;i++)
690         tab[i] = val;
691 }
692
693 int msmpeg4_decode_mb(MpegEncContext *s, 
694                       DCTELEM block[6][64])
695 {
696     int cbp, code, i;
697     int pred, val;
698     UINT8 *coded_val;
699
700     /* special slice handling */
701     if (s->mb_x == 0) {
702         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
703             int wrap;
704             /* reset DC pred (set previous line to 1024) */
705             wrap = 2 * s->mb_width + 2;
706             memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap], 
707                     1024, 2 * s->mb_width);
708             wrap = s->mb_width + 2;
709             memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap], 
710                     1024, s->mb_width);
711             memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap], 
712                     1024, s->mb_width);
713             
714             /* reset AC pred (set previous line to 0) */
715             wrap = s->mb_width * 2 + 2;
716             memsetw(s->ac_val[0][0] + (1 + (2 * s->mb_y) * wrap)*16,
717                     0, 2 * s->mb_width*16);
718             wrap = s->mb_width + 2;
719             memsetw(s->ac_val[1][0] + (1 + (s->mb_y) * wrap)*16,
720                     0, s->mb_width*16);
721             memsetw(s->ac_val[2][0] + (1 + (s->mb_y) * wrap)*16,
722                     0, s->mb_width*16);
723
724             s->first_slice_line = 1;
725         } else {
726             s->first_slice_line = 0; 
727         }
728     }
729
730     if (s->pict_type == P_TYPE) {
731         set_stat(ST_INTER_MB);
732         if (s->use_skip_mb_code) {
733             if (get_bits1(&s->gb)) {
734                 /* skip mb */
735                 s->mb_intra = 0;
736                 for(i=0;i<6;i++)
737                     s->block_last_index[i] = -1;
738                 s->mv_dir = MV_DIR_FORWARD;
739                 s->mv_type = MV_TYPE_16X16;
740                 s->mv[0][0][0] = 0;
741                 s->mv[0][0][1] = 0;
742                 s->mb_skiped = 1;
743                 return 0;
744             }
745         }
746         
747         code = get_vlc(&s->gb, &mb_non_intra_vlc);
748         if (code < 0)
749             return -1;
750         if (code & 0x40)
751             s->mb_intra = 0;
752         else
753             s->mb_intra = 1;
754             
755         cbp = code & 0x3f;
756     } else {
757         set_stat(ST_INTRA_MB);
758         s->mb_intra = 1;
759         code = get_vlc(&s->gb, &mb_intra_vlc);
760         if (code < 0)
761             return -1;
762         /* predict coded block pattern */
763         cbp = 0;
764         for(i=0;i<6;i++) {
765             val = ((code >> (5 - i)) & 1);
766             if (i < 4) {
767                 pred = coded_block_pred(s, i, &coded_val);
768                 val = val ^ pred;
769                 *coded_val = val;
770             }
771             cbp |= val << (5 - i);
772         }
773     }
774
775     if (!s->mb_intra) {
776         int mx, my;
777         set_stat(ST_MV);
778         h263_pred_motion(s, 0, &mx, &my);
779         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
780             return -1;
781         s->mv_dir = MV_DIR_FORWARD;
782         s->mv_type = MV_TYPE_16X16;
783         s->mv[0][0][0] = mx;
784         s->mv[0][0][1] = my;
785     } else {
786         set_stat(ST_INTRA_MB);
787         s->ac_pred = get_bits1(&s->gb);
788     }
789
790     for (i = 0; i < 6; i++) {
791         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
792             return -1;
793     }
794     return 0;
795 }
796
797 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
798                               int n, int coded)
799 {
800     int code, level, i, j, last, run, run_diff;
801     int dc_pred_dir;
802     RLTable *rl;
803     const UINT8 *scan_table;
804     int qmul, qadd;
805
806     if (s->mb_intra) {
807         qmul=1;
808         qadd=0;
809
810         /* DC coef */
811         set_stat(ST_DC);
812         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
813         if (level < 0)
814             return -1;
815         block[0] = level;
816         if (n < 4) {
817             rl = &rl_table[s->rl_table_index];
818         } else {
819             rl = &rl_table[3 + s->rl_chroma_table_index];
820         }
821
822         run_diff = 0;
823         i = 1;
824         if (!coded) {
825             goto not_coded;
826         }
827         if (s->ac_pred) {
828             if (dc_pred_dir == 0) 
829                 scan_table = ff_alternate_vertical_scan; /* left */
830             else
831                 scan_table = ff_alternate_horizontal_scan; /* top */
832         } else {
833             scan_table = zigzag_direct;
834         }
835         set_stat(ST_INTRA_AC);
836     } else {
837         qmul = s->qscale << 1;
838         qadd = (s->qscale - 1) | 1;
839         i = 0;
840         rl = &rl_table[3 + s->rl_table_index];
841         run_diff = 1;
842         if (!coded) {
843             s->block_last_index[n] = i - 1;
844             return 0;
845         }
846         scan_table = zigzag_direct;
847         set_stat(ST_INTER_AC);
848     }
849
850     for(;;) {
851         code = get_vlc(&s->gb, &rl->vlc);
852         if (code < 0)
853             return -1;
854         if (code == rl->n) {
855             /* escape */
856             if (get_bits1(&s->gb) == 0) {
857                 if (get_bits1(&s->gb) == 0) {
858                     /* third escape */
859                     last = get_bits1(&s->gb);
860                     run = get_bits(&s->gb, 6);
861                     level = get_bits(&s->gb, 8);
862                     level = (level << 24) >> 24; /* sign extend */
863                     if(level>0) level= level * qmul + qadd;
864                     else        level= level * qmul - qadd;
865                 } else {
866                     /* second escape */
867                     code = get_vlc(&s->gb, &rl->vlc);
868                     if (code < 0 || code >= rl->n)
869                         return -1;
870                     run = rl->table_run[code];
871                     level = rl->table_level[code] * qmul + qadd;
872                     last = code >= rl->last;
873                     run += rl->max_run[last][level] + run_diff;
874                     if (get_bits1(&s->gb))
875                         level = -level;
876                 }
877             } else {
878                 /* first escape */
879                 code = get_vlc(&s->gb, &rl->vlc);
880                 if (code < 0 || code >= rl->n)
881                     return -1;
882                 run = rl->table_run[code];
883                 level = rl->table_level[code];
884                 last = code >= rl->last;
885                 level += rl->max_level[last][run];
886                 level= level * qmul + qadd;
887                 if (get_bits1(&s->gb))
888                     level = -level;
889             }
890         } else {
891             run = rl->table_run[code];
892             level = rl->table_level[code] * qmul + qadd;
893             last = code >= rl->last;
894             if (get_bits1(&s->gb))
895                 level = -level;
896         }
897         i += run;
898         if (i >= 64)
899             return -1;
900         j = scan_table[i];
901         block[j] = level;
902         i++;
903         if (last)
904             break;
905     }
906  not_coded:
907     if (s->mb_intra) {
908         mpeg4_pred_ac(s, block, n, dc_pred_dir);
909         if (s->ac_pred) {
910             i = 64; /* XXX: not optimal */
911         }
912     }
913     s->block_last_index[n] = i - 1;
914
915     return 0;
916 }
917
918 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
919 {
920     int level, pred;
921     INT16 *dc_val;
922
923     if (n < 4) {
924         level = get_vlc(&s->gb, &dc_lum_vlc[s->dc_table_index]);
925     } else {
926         level = get_vlc(&s->gb, &dc_chroma_vlc[s->dc_table_index]);
927     }
928     if (level < 0)
929         return -1;
930
931     if (level == DC_MAX) {
932         level = get_bits(&s->gb, 8);
933         if (get_bits1(&s->gb))
934             level = -level;
935     } else if (level != 0) {
936         if (get_bits1(&s->gb))
937             level = -level;
938     }
939
940     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
941     level += pred;
942
943     /* update predictor */
944     if (n < 4) {
945         *dc_val = level * s->y_dc_scale;
946     } else {
947         *dc_val = level * s->c_dc_scale;
948     }
949
950     return level;
951 }
952
953 static int msmpeg4_decode_motion(MpegEncContext * s, 
954                                  int *mx_ptr, int *my_ptr)
955 {
956     MVTable *mv;
957     int code, mx, my;
958
959     mv = &mv_tables[s->mv_table_index];
960
961     code = get_vlc(&s->gb, &mv->vlc);
962     if (code < 0)
963         return -1;
964     if (code == mv->n) {
965         mx = get_bits(&s->gb, 6);
966         my = get_bits(&s->gb, 6);
967     } else {
968         mx = mv->table_mvx[code];
969         my = mv->table_mvy[code];
970     }
971
972     mx += *mx_ptr - 32;
973     my += *my_ptr - 32;
974     /* WARNING : they do not do exactly modulo encoding */
975     if (mx <= -64)
976         mx += 64;
977     else if (mx >= 64)
978         mx -= 64;
979
980     if (my <= -64)
981         my += 64;
982     else if (my >= 64)
983         my -= 64;
984     *mx_ptr = mx;
985     *my_ptr = my;
986     return 0;
987 }