044d964ee5baa608e04a81854e83e3d03fb4b17b
[libav.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 int scale;
351
352 if (s->qscale < 5)
353 scale = 8;
354 else if (s->qscale < 9)
355 scale = 2 * s->qscale;
356 else
357 scale = s->qscale + 8;
358 s->y_dc_scale = scale;
359 s->c_dc_scale = (s->qscale + 13) / 2;
360 }
361
362 /* dir = 0: left, dir = 1: top prediction */
363 static int msmpeg4_pred_dc(MpegEncContext * s, int n,
364 UINT16 **dc_val_ptr, int *dir_ptr)
365 {
366 int a, b, c, x, y, wrap, pred, scale;
367 UINT16 *dc_val;
368
369 /* find prediction */
370 if (n < 4) {
371 x = 2 * s->mb_x + 1 + (n & 1);
372 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
373 wrap = s->mb_width * 2 + 2;
374 dc_val = s->dc_val[0];
375 scale = s->y_dc_scale;
376 } else {
377 x = s->mb_x + 1;
378 y = s->mb_y + 1;
379 wrap = s->mb_width + 2;
380 dc_val = s->dc_val[n - 4 + 1];
381 scale = s->c_dc_scale;
382 }
383
384 /* B C
385 * A X
386 */
387 a = dc_val[(x - 1) + (y) * wrap];
388 b = dc_val[(x - 1) + (y - 1) * wrap];
389 c = dc_val[(x) + (y - 1) * wrap];
390
391 /* XXX: the following solution consumes divisions, but it does not
392 necessitate to modify mpegvideo.c. The problem comes from the
393 fact they decided to store the quantized DC (which would lead
394 to problems if Q could vary !) */
395 a = (a + (scale >> 1)) / scale;
396 b = (b + (scale >> 1)) / scale;
397 c = (c + (scale >> 1)) / scale;
398
399 /* XXX: WARNING: they did not choose the same test as MPEG4. This
400 is very important ! */
401 if (abs(a - b) <= abs(b - c)) {
402 pred = c;
403 *dir_ptr = 1;
404 } else {
405 pred = a;
406 *dir_ptr = 0;
407 }
408
409 /* update predictor */
410 *dc_val_ptr = &dc_val[(x) + (y) * wrap];
411 return pred;
412 }
413
414 #define DC_MAX 119
415
416 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
417 {
418 int sign, code;
419 int pred;
420 UINT16 *dc_val;
421
422 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
423
424 /* update predictor */
425 if (n < 4) {
426 *dc_val = level * s->y_dc_scale;
427 } else {
428 *dc_val = level * s->c_dc_scale;
429 }
430
431 /* do the prediction */
432 level -= pred;
433
434 sign = 0;
435 if (level < 0) {
436 level = -level;
437 sign = 1;
438 }
439
440 code = level;
441 if (code > DC_MAX)
442 code = DC_MAX;
443
444 if (s->dc_table_index == 0) {
445 if (n < 4) {
446 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
447 } else {
448 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
449 }
450 } else {
451 if (n < 4) {
452 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
453 } else {
454 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
455 }
456 }
457
458 if (code == DC_MAX)
459 put_bits(&s->pb, 8, level);
460
461 if (level != 0) {
462 put_bits(&s->pb, 1, sign);
463 }
464 }
465
466 /* Encoding of a block. Very similar to MPEG4 except for a different
467 escape coding (same as H263) and more vlc tables.
468 */
469 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
470 {
471 int level, run, last, i, j, last_index;
472 int last_non_zero, sign, slevel;
473 int code, run_diff, dc_pred_dir;
474 const RLTable *rl;
475
476 if (s->mb_intra) {
477 set_stat(ST_DC);
478 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
479 i = 1;
480 if (n < 4) {
481 rl = &rl_table[s->rl_table_index];
482 } else {
483 rl = &rl_table[3 + s->rl_chroma_table_index];
484 }
485 run_diff = 0;
486 set_stat(ST_INTRA_AC);
487 } else {
488 i = 0;
489 rl = &rl_table[3 + s->rl_table_index];
490 run_diff = 1;
491 set_stat(ST_INTER_AC);
492 }
493
494 /* AC coefs */
495 last_index = s->block_last_index[n];
496 last_non_zero = i - 1;
497 for (; i <= last_index; i++) {
498 j = zigzag_direct[i];
499 level = block[j];
500 if (level) {
501 run = i - last_non_zero - 1;
502 last = (i == last_index);
503 sign = 0;
504 slevel = level;
505 if (level < 0) {
506 sign = 1;
507 level = -level;
508 }
509 code = get_rl_index(rl, last, run, level);
510 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
511 if (code == rl->n) {
512 int level1, run1;
513
514 level1 = level - rl->max_level[last][run];
515 if (level1 < 1)
516 goto esc2;
517 code = get_rl_index(rl, last, run, level1);
518 if (code == rl->n) {
519 esc2:
520 put_bits(&s->pb, 1, 0);
521 if (level > MAX_LEVEL)
522 goto esc3;
523 run1 = run - rl->max_run[last][level] - run_diff;
524 if (run1 < 0)
525 goto esc3;
526 code = get_rl_index(rl, last, run1, level);
527 if (code == rl->n) {
528 esc3:
529 /* third escape */
530 put_bits(&s->pb, 1, 0);
531 put_bits(&s->pb, 1, last);
532 put_bits(&s->pb, 6, run);
533 put_bits(&s->pb, 8, slevel & 0xff);
534 } else {
535 /* second escape */
536 put_bits(&s->pb, 1, 1);
537 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
538 put_bits(&s->pb, 1, sign);
539 }
540 } else {
541 /* first escape */
542 put_bits(&s->pb, 1, 1);
543 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
544 put_bits(&s->pb, 1, sign);
545 }
546 } else {
547 put_bits(&s->pb, 1, sign);
548 }
549 last_non_zero = i;
550 }
551 }
552 }
553
554 /****************************************/
555 /* decoding stuff */
556
557 static VLC mb_non_intra_vlc;
558 static VLC mb_intra_vlc;
559 static VLC dc_lum_vlc[2];
560 static VLC dc_chroma_vlc[2];
561
562 /* init all vlc decoding tables */
563 int msmpeg4_decode_init_vlc(MpegEncContext *s)
564 {
565 int i;
566 MVTable *mv;
567
568 for(i=0;i<NB_RL_TABLES;i++) {
569 init_rl(&rl_table[i]);
570 init_vlc_rl(&rl_table[i]);
571 }
572 for(i=0;i<2;i++) {
573 mv = &mv_tables[i];
574 init_vlc(&mv->vlc, 9, mv->n + 1,
575 mv->table_mv_bits, 1, 1,
576 mv->table_mv_code, 2, 2);
577 }
578
579 init_vlc(&dc_lum_vlc[0], 9, 120,
580 &table0_dc_lum[0][1], 8, 4,
581 &table0_dc_lum[0][0], 8, 4);
582 init_vlc(&dc_chroma_vlc[0], 9, 120,
583 &table0_dc_chroma[0][1], 8, 4,
584 &table0_dc_chroma[0][0], 8, 4);
585 init_vlc(&dc_lum_vlc[1], 9, 120,
586 &table1_dc_lum[0][1], 8, 4,
587 &table1_dc_lum[0][0], 8, 4);
588 init_vlc(&dc_chroma_vlc[1], 9, 120,
589 &table1_dc_chroma[0][1], 8, 4,
590 &table1_dc_chroma[0][0], 8, 4);
591
592 init_vlc(&mb_non_intra_vlc, 9, 128,
593 &table_mb_non_intra[0][1], 8, 4,
594 &table_mb_non_intra[0][0], 8, 4);
595 init_vlc(&mb_intra_vlc, 9, 128,
596 &table_mb_intra[0][1], 4, 2,
597 &table_mb_intra[0][0], 4, 2);
598 return 0;
599 }
600
601 static int decode012(GetBitContext *gb)
602 {
603 int n;
604 n = get_bits(gb, 1);
605 if (n == 0)
606 return 0;
607 else
608 return get_bits(gb, 1) + 1;
609 }
610
611 int msmpeg4_decode_picture_header(MpegEncContext * s)
612 {
613 int code;
614
615 s->pict_type = get_bits(&s->gb, 2) + 1;
616 if (s->pict_type != I_TYPE &&
617 s->pict_type != P_TYPE)
618 return -1;
619
620 s->qscale = get_bits(&s->gb, 5);
621
622 if (s->pict_type == I_TYPE) {
623 code = get_bits(&s->gb, 5);
624 /* 0x17: one slice, 0x18: three slices */
625 /* XXX: implement it */
626 if (code < 0x17)
627 return -1;
628 s->slice_height = s->mb_height / (code - 0x16);
629 s->rl_chroma_table_index = decode012(&s->gb);
630 s->rl_table_index = decode012(&s->gb);
631
632 s->dc_table_index = get_bits(&s->gb, 1);
633 s->no_rounding = 1;
634 } else {
635 s->use_skip_mb_code = get_bits(&s->gb, 1);
636
637 s->rl_table_index = decode012(&s->gb);
638 s->rl_chroma_table_index = s->rl_table_index;
639
640 s->dc_table_index = get_bits(&s->gb, 1);
641
642 s->mv_table_index = get_bits(&s->gb, 1);
643 s->no_rounding ^= 1;
644 }
645 #ifdef DEBUG
646 printf("*****frame %d:\n", frame_count++);
647 #endif
648 return 0;
649 }
650
651 void memsetw(short *tab, int val, int n)
652 {
653 int i;
654 for(i=0;i<n;i++)
655 tab[i] = val;
656 }
657
658 int msmpeg4_decode_mb(MpegEncContext *s,
659 DCTELEM block[6][64])
660 {
661 int cbp, code, i;
662 int pred, val;
663 UINT8 *coded_val;
664
665 /* special slice handling */
666 if (s->mb_x == 0) {
667 if ((s->mb_y % s->slice_height) == 0) {
668 int wrap;
669 /* reset DC pred (set previous line to 1024) */
670 wrap = 2 * s->mb_width + 2;
671 memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap],
672 1024, 2 * s->mb_width);
673 wrap = s->mb_width + 2;
674 memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap],
675 1024, s->mb_width);
676 memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap],
677 1024, s->mb_width);
678
679 s->first_slice_line = 1;
680 } else {
681 s->first_slice_line = 0;
682 }
683 }
684
685 if (s->pict_type == P_TYPE) {
686 set_stat(ST_INTER_MB);
687 if (s->use_skip_mb_code) {
688 if (get_bits(&s->gb, 1)) {
689 /* skip mb */
690 s->mb_intra = 0;
691 for(i=0;i<6;i++)
692 s->block_last_index[i] = -1;
693 s->mv_dir = MV_DIR_FORWARD;
694 s->mv_type = MV_TYPE_16X16;
695 s->mv[0][0][0] = 0;
696 s->mv[0][0][1] = 0;
697 return 0;
698 }
699 }
700
701 code = get_vlc(&s->gb, &mb_non_intra_vlc);
702 if (code < 0)
703 return -1;
704 if (code & 0x40)
705 s->mb_intra = 0;
706 else
707 s->mb_intra = 1;
708
709 cbp = code & 0x3f;
710 } else {
711 set_stat(ST_INTRA_MB);
712 s->mb_intra = 1;
713 code = get_vlc(&s->gb, &mb_intra_vlc);
714 if (code < 0)
715 return -1;
716 /* predict coded block pattern */
717 cbp = 0;
718 for(i=0;i<6;i++) {
719 val = ((code >> (5 - i)) & 1);
720 if (i < 4) {
721 pred = coded_block_pred(s, i, &coded_val);
722 val = val ^ pred;
723 *coded_val = val;
724 }
725 cbp |= val << (5 - i);
726 }
727 }
728
729 if (!s->mb_intra) {
730 int mx, my;
731 set_stat(ST_MV);
732 h263_pred_motion(s, 0, &mx, &my);
733 if (msmpeg4_decode_motion(s, &mx, &my) < 0)
734 return -1;
735 s->mv_dir = MV_DIR_FORWARD;
736 s->mv_type = MV_TYPE_16X16;
737 s->mv[0][0][0] = mx;
738 s->mv[0][0][1] = my;
739 } else {
740 set_stat(ST_INTRA_MB);
741 s->ac_pred = get_bits(&s->gb, 1);
742 }
743
744 for (i = 0; i < 6; i++) {
745 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
746 return -1;
747 }
748 return 0;
749 }
750
751 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
752 int n, int coded)
753 {
754 int code, level, i, j, last, run, run_diff;
755 int dc_pred_dir;
756 RLTable *rl;
757 const UINT8 *scan_table;
758
759 if (s->mb_intra) {
760 /* DC coef */
761 set_stat(ST_DC);
762 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
763 if (level < 0)
764 return -1;
765 block[0] = level;
766 if (n < 4) {
767 rl = &rl_table[s->rl_table_index];
768 } else {
769 rl = &rl_table[3 + s->rl_chroma_table_index];
770 }
771 run_diff = 0;
772 i = 1;
773 if (!coded) {
774 goto not_coded;
775 }
776 if (s->ac_pred) {
777 if (dc_pred_dir == 0)
778 scan_table = ff_alternate_vertical_scan; /* left */
779 else
780 scan_table = ff_alternate_horizontal_scan; /* top */
781 } else {
782 scan_table = zigzag_direct;
783 }
784 set_stat(ST_INTRA_AC);
785 } else {
786 i = 0;
787 rl = &rl_table[3 + s->rl_table_index];
788 run_diff = 1;
789 if (!coded) {
790 s->block_last_index[n] = i - 1;
791 return 0;
792 }
793 scan_table = zigzag_direct;
794 set_stat(ST_INTER_AC);
795 }
796
797 for(;;) {
798 code = get_vlc(&s->gb, &rl->vlc);
799 if (code < 0)
800 return -1;
801 if (code == rl->n) {
802 /* escape */
803 if (get_bits(&s->gb, 1) == 0) {
804 if (get_bits(&s->gb, 1) == 0) {
805 /* third escape */
806 last = get_bits(&s->gb, 1);
807 run = get_bits(&s->gb, 6);
808 level = get_bits(&s->gb, 8);
809 level = (level << 24) >> 24; /* sign extend */
810 } else {
811 /* second escape */
812 code = get_vlc(&s->gb, &rl->vlc);
813 if (code < 0 || code >= rl->n)
814 return -1;
815 run = rl->table_run[code];
816 level = rl->table_level[code];
817 last = code >= rl->last;
818 run += rl->max_run[last][level] + run_diff;
819 if (get_bits(&s->gb, 1))
820 level = -level;
821 }
822 } else {
823 /* first escape */
824 code = get_vlc(&s->gb, &rl->vlc);
825 if (code < 0 || code >= rl->n)
826 return -1;
827 run = rl->table_run[code];
828 level = rl->table_level[code];
829 last = code >= rl->last;
830 level += rl->max_level[last][run];
831 if (get_bits(&s->gb, 1))
832 level = -level;
833 }
834 } else {
835 run = rl->table_run[code];
836 level = rl->table_level[code];
837 last = code >= rl->last;
838 if (get_bits(&s->gb, 1))
839 level = -level;
840 }
841 i += run;
842 if (i >= 64)
843 return -1;
844 j = scan_table[i];
845 block[j] = level;
846 i++;
847 if (last)
848 break;
849 }
850 not_coded:
851 if (s->mb_intra) {
852 mpeg4_pred_ac(s, block, n, dc_pred_dir);
853 if (s->ac_pred) {
854 i = 64; /* XXX: not optimal */
855 }
856 }
857 s->block_last_index[n] = i - 1;
858
859 return 0;
860 }
861
862 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
863 {
864 int level, pred;
865 UINT16 *dc_val;
866
867 if (n < 4) {
868 level = get_vlc(&s->gb, &dc_lum_vlc[s->dc_table_index]);
869 } else {
870 level = get_vlc(&s->gb, &dc_chroma_vlc[s->dc_table_index]);
871 }
872 if (level < 0)
873 return -1;
874
875 if (level == DC_MAX) {
876 level = get_bits(&s->gb, 8);
877 if (get_bits(&s->gb, 1))
878 level = -level;
879 } else if (level != 0) {
880 if (get_bits(&s->gb, 1))
881 level = -level;
882 }
883
884 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
885 level += pred;
886
887 /* update predictor */
888 if (n < 4) {
889 *dc_val = level * s->y_dc_scale;
890 } else {
891 *dc_val = level * s->c_dc_scale;
892 }
893
894 return level;
895 }
896
897 static int msmpeg4_decode_motion(MpegEncContext * s,
898 int *mx_ptr, int *my_ptr)
899 {
900 MVTable *mv;
901 int code, mx, my;
902
903 mv = &mv_tables[s->mv_table_index];
904
905 code = get_vlc(&s->gb, &mv->vlc);
906 if (code < 0)
907 return -1;
908 if (code == mv->n) {
909 mx = get_bits(&s->gb, 6);
910 my = get_bits(&s->gb, 6);
911 } else {
912 mx = mv->table_mvx[code];
913 my = mv->table_mvy[code];
914 }
915
916 mx += *mx_ptr - 32;
917 my += *my_ptr - 32;
918 /* WARNING : they do not do exactly modulo encoding */
919 if (mx <= -64)
920 mx += 64;
921 else if (mx >= 64)
922 mx -= 64;
923
924 if (my <= -64)
925 my += 64;
926 else if (my >= 64)
927 my -= 64;
928 *mx_ptr = mx;
929 *my_ptr = my;
930 return 0;
931 }