9a2cb53ff8a672404b5da3d3bdbafdb62b26e99c
[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
634     s->pict_type = get_bits(&s->gb, 2) + 1;
635     if (s->pict_type != I_TYPE &&
636         s->pict_type != P_TYPE)
637         return -1;
638
639     s->qscale = get_bits(&s->gb, 5);
640
641     if (s->pict_type == I_TYPE) {
642         code = get_bits(&s->gb, 5); 
643         /* 0x17: one slice, 0x18: three slices */
644         /* XXX: implement it */
645         if (code < 0x17)
646             return -1;
647         s->slice_height = s->mb_height / (code - 0x16);
648         s->rl_chroma_table_index = decode012(&s->gb);
649         s->rl_table_index = decode012(&s->gb);
650
651         s->dc_table_index = get_bits1(&s->gb);
652         s->no_rounding = 1;
653     } else {
654         s->use_skip_mb_code = get_bits1(&s->gb);
655         
656         s->rl_table_index = decode012(&s->gb);
657         s->rl_chroma_table_index = s->rl_table_index;
658
659         s->dc_table_index = get_bits1(&s->gb);
660
661         s->mv_table_index = get_bits1(&s->gb);
662         s->no_rounding ^= 1;
663     }
664 #ifdef DEBUG
665     printf("*****frame %d:\n", frame_count++);
666 #endif
667     return 0;
668 }
669
670 void memsetw(short *tab, int val, int n)
671 {
672     int i;
673     for(i=0;i<n;i++)
674         tab[i] = val;
675 }
676
677 int msmpeg4_decode_mb(MpegEncContext *s, 
678                       DCTELEM block[6][64])
679 {
680     int cbp, code, i;
681     int pred, val;
682     UINT8 *coded_val;
683
684     /* special slice handling */
685     if (s->mb_x == 0) {
686         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
687             int wrap;
688             /* reset DC pred (set previous line to 1024) */
689             wrap = 2 * s->mb_width + 2;
690             memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap], 
691                     1024, 2 * s->mb_width);
692             wrap = s->mb_width + 2;
693             memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap], 
694                     1024, s->mb_width);
695             memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap], 
696                     1024, s->mb_width);
697             
698             /* reset AC pred (set previous line to 0) */
699             wrap = s->mb_width * 2 + 2;
700             memsetw(s->ac_val[0][0] + (1 + (2 * s->mb_y) * wrap)*16,
701                     0, 2 * s->mb_width*16);
702             wrap = s->mb_width + 2;
703             memsetw(s->ac_val[1][0] + (1 + (s->mb_y) * wrap)*16,
704                     0, s->mb_width*16);
705             memsetw(s->ac_val[2][0] + (1 + (s->mb_y) * wrap)*16,
706                     0, s->mb_width*16);
707
708             s->first_slice_line = 1;
709         } else {
710             s->first_slice_line = 0; 
711         }
712     }
713
714     if (s->pict_type == P_TYPE) {
715         set_stat(ST_INTER_MB);
716         if (s->use_skip_mb_code) {
717             if (get_bits1(&s->gb)) {
718                 /* skip mb */
719                 s->mb_intra = 0;
720                 for(i=0;i<6;i++)
721                     s->block_last_index[i] = -1;
722                 s->mv_dir = MV_DIR_FORWARD;
723                 s->mv_type = MV_TYPE_16X16;
724                 s->mv[0][0][0] = 0;
725                 s->mv[0][0][1] = 0;
726                 s->mb_skiped = 1;
727                 return 0;
728             }
729         }
730         
731         code = get_vlc(&s->gb, &mb_non_intra_vlc);
732         if (code < 0)
733             return -1;
734         if (code & 0x40)
735             s->mb_intra = 0;
736         else
737             s->mb_intra = 1;
738             
739         cbp = code & 0x3f;
740     } else {
741         set_stat(ST_INTRA_MB);
742         s->mb_intra = 1;
743         code = get_vlc(&s->gb, &mb_intra_vlc);
744         if (code < 0)
745             return -1;
746         /* predict coded block pattern */
747         cbp = 0;
748         for(i=0;i<6;i++) {
749             val = ((code >> (5 - i)) & 1);
750             if (i < 4) {
751                 pred = coded_block_pred(s, i, &coded_val);
752                 val = val ^ pred;
753                 *coded_val = val;
754             }
755             cbp |= val << (5 - i);
756         }
757     }
758
759     if (!s->mb_intra) {
760         int mx, my;
761         set_stat(ST_MV);
762         h263_pred_motion(s, 0, &mx, &my);
763         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
764             return -1;
765         s->mv_dir = MV_DIR_FORWARD;
766         s->mv_type = MV_TYPE_16X16;
767         s->mv[0][0][0] = mx;
768         s->mv[0][0][1] = my;
769     } else {
770         set_stat(ST_INTRA_MB);
771         s->ac_pred = get_bits1(&s->gb);
772     }
773
774     for (i = 0; i < 6; i++) {
775         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
776             return -1;
777     }
778     return 0;
779 }
780
781 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
782                               int n, int coded)
783 {
784     int code, level, i, j, last, run, run_diff;
785     int dc_pred_dir;
786     RLTable *rl;
787     const UINT8 *scan_table;
788
789     if (s->mb_intra) {
790         /* DC coef */
791         set_stat(ST_DC);
792         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
793         if (level < 0)
794             return -1;
795         block[0] = level;
796         if (n < 4) {
797             rl = &rl_table[s->rl_table_index];
798         } else {
799             rl = &rl_table[3 + s->rl_chroma_table_index];
800         }
801         run_diff = 0;
802         i = 1;
803         if (!coded) {
804             goto not_coded;
805         }
806         if (s->ac_pred) {
807             if (dc_pred_dir == 0) 
808                 scan_table = ff_alternate_vertical_scan; /* left */
809             else
810                 scan_table = ff_alternate_horizontal_scan; /* top */
811         } else {
812             scan_table = zigzag_direct;
813         }
814         set_stat(ST_INTRA_AC);
815     } else {
816         i = 0;
817         rl = &rl_table[3 + s->rl_table_index];
818         run_diff = 1;
819         if (!coded) {
820             s->block_last_index[n] = i - 1;
821             return 0;
822         }
823         scan_table = zigzag_direct;
824         set_stat(ST_INTER_AC);
825     }
826
827     for(;;) {
828         code = get_vlc(&s->gb, &rl->vlc);
829         if (code < 0)
830             return -1;
831         if (code == rl->n) {
832             /* escape */
833             if (get_bits1(&s->gb) == 0) {
834                 if (get_bits1(&s->gb) == 0) {
835                     /* third escape */
836                     last = get_bits1(&s->gb);
837                     run = get_bits(&s->gb, 6);
838                     level = get_bits(&s->gb, 8);
839                     level = (level << 24) >> 24; /* sign extend */
840                 } else {
841                     /* second escape */
842                     code = get_vlc(&s->gb, &rl->vlc);
843                     if (code < 0 || code >= rl->n)
844                         return -1;
845                     run = rl->table_run[code];
846                     level = rl->table_level[code];
847                     last = code >= rl->last;
848                     run += rl->max_run[last][level] + run_diff;
849                     if (get_bits1(&s->gb))
850                         level = -level;
851                 }
852             } else {
853                 /* first escape */
854                 code = get_vlc(&s->gb, &rl->vlc);
855                 if (code < 0 || code >= rl->n)
856                     return -1;
857                 run = rl->table_run[code];
858                 level = rl->table_level[code];
859                 last = code >= rl->last;
860                 level += rl->max_level[last][run];
861                 if (get_bits1(&s->gb))
862                     level = -level;
863             }
864         } else {
865             run = rl->table_run[code];
866             level = rl->table_level[code];
867             last = code >= rl->last;
868             if (get_bits1(&s->gb))
869                 level = -level;
870         }
871         i += run;
872         if (i >= 64)
873             return -1;
874         j = scan_table[i];
875         block[j] = level;
876         i++;
877         if (last)
878             break;
879     }
880  not_coded:
881     if (s->mb_intra) {
882         mpeg4_pred_ac(s, block, n, dc_pred_dir);
883         if (s->ac_pred) {
884             i = 64; /* XXX: not optimal */
885         }
886     }
887     s->block_last_index[n] = i - 1;
888
889     return 0;
890 }
891
892 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
893 {
894     int level, pred;
895     INT16 *dc_val;
896
897     if (n < 4) {
898         level = get_vlc(&s->gb, &dc_lum_vlc[s->dc_table_index]);
899     } else {
900         level = get_vlc(&s->gb, &dc_chroma_vlc[s->dc_table_index]);
901     }
902     if (level < 0)
903         return -1;
904
905     if (level == DC_MAX) {
906         level = get_bits(&s->gb, 8);
907         if (get_bits1(&s->gb))
908             level = -level;
909     } else if (level != 0) {
910         if (get_bits1(&s->gb))
911             level = -level;
912     }
913
914     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
915     level += pred;
916
917     /* update predictor */
918     if (n < 4) {
919         *dc_val = level * s->y_dc_scale;
920     } else {
921         *dc_val = level * s->c_dc_scale;
922     }
923
924     return level;
925 }
926
927 static int msmpeg4_decode_motion(MpegEncContext * s, 
928                                  int *mx_ptr, int *my_ptr)
929 {
930     MVTable *mv;
931     int code, mx, my;
932
933     mv = &mv_tables[s->mv_table_index];
934
935     code = get_vlc(&s->gb, &mv->vlc);
936     if (code < 0)
937         return -1;
938     if (code == mv->n) {
939         mx = get_bits(&s->gb, 6);
940         my = get_bits(&s->gb, 6);
941     } else {
942         mx = mv->table_mvx[code];
943         my = mv->table_mvy[code];
944     }
945
946     mx += *mx_ptr - 32;
947     my += *my_ptr - 32;
948     /* WARNING : they do not do exactly modulo encoding */
949     if (mx <= -64)
950         mx += 64;
951     else if (mx >= 64)
952         mx -= 64;
953
954     if (my <= -64)
955         my += 64;
956     else if (my >= 64)
957         my -= 64;
958     *mx_ptr = mx;
959     *my_ptr = my;
960     return 0;
961 }