(commited by michael / arpi was crazy enough to give me his password)
[libav.git] / libavcodec / msmpeg4.c
CommitLineData
de6d9b64
FB
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 */
36typedef 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
46static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
47static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
48 int n, int coded);
49static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
50static int msmpeg4_decode_motion(MpegEncContext * s,
51 int *mx_ptr, int *my_ptr);
52
53#ifdef DEBUG
54int intra_count = 0;
55int frame_count = 0;
56#endif
57/* XXX: move it to mpegvideo.h */
58
59static int init_done = 0;
60
61#include "msmpeg4data.h"
62
63#ifdef STATS
64
65const 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
75int st_current_index = 0;
76unsigned int st_bit_counts[ST_NB];
77unsigned int st_out_bit_counts[ST_NB];
78
79#define set_stat(var) st_current_index = var;
80
81void 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 */
128static 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
144static 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 */
155void 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 */
207static 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
234static 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
273void 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 ! */
348void msmpeg4_dc_scale(MpegEncContext * s)
349{
6fb904ce
MN
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 */
de6d9b64
FB
379}
380
381/* dir = 0: left, dir = 1: top prediction */
382static int msmpeg4_pred_dc(MpegEncContext * s, int n,
98be975d 383 INT16 **dc_val_ptr, int *dir_ptr)
de6d9b64
FB
384{
385 int a, b, c, x, y, wrap, pred, scale;
98be975d 386 INT16 *dc_val;
de6d9b64
FB
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
435static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
436{
437 int sign, code;
438 int pred;
98be975d 439 INT16 *dc_val;
de6d9b64
FB
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 */
488static 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
576static VLC mb_non_intra_vlc;
577static VLC mb_intra_vlc;
578static VLC dc_lum_vlc[2];
579static VLC dc_chroma_vlc[2];
580
581/* init all vlc decoding tables */
582int 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);
2cb1773d 614 init_vlc(&mb_intra_vlc, 9, 64,
de6d9b64
FB
615 &table_mb_intra[0][1], 4, 2,
616 &table_mb_intra[0][0], 4, 2);
617 return 0;
618}
619
620static int decode012(GetBitContext *gb)
621{
622 int n;
612476ef 623 n = get_bits1(gb);
de6d9b64
FB
624 if (n == 0)
625 return 0;
626 else
612476ef 627 return get_bits1(gb) + 1;
de6d9b64
FB
628}
629
630int 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
612476ef 651 s->dc_table_index = get_bits1(&s->gb);
de6d9b64
FB
652 s->no_rounding = 1;
653 } else {
612476ef 654 s->use_skip_mb_code = get_bits1(&s->gb);
de6d9b64
FB
655
656 s->rl_table_index = decode012(&s->gb);
657 s->rl_chroma_table_index = s->rl_table_index;
658
612476ef 659 s->dc_table_index = get_bits1(&s->gb);
de6d9b64 660
612476ef 661 s->mv_table_index = get_bits1(&s->gb);
de6d9b64
FB
662 s->no_rounding ^= 1;
663 }
664#ifdef DEBUG
665 printf("*****frame %d:\n", frame_count++);
666#endif
667 return 0;
668}
669
670void memsetw(short *tab, int val, int n)
671{
672 int i;
673 for(i=0;i<n;i++)
674 tab[i] = val;
675}
676
677int 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) {
525782f3 686 if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
de6d9b64
FB
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);
3046f265
MN
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);
de6d9b64
FB
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) {
612476ef 717 if (get_bits1(&s->gb)) {
de6d9b64
FB
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;
3bb4e23a 726 s->mb_skiped = 1;
de6d9b64
FB
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);
612476ef 771 s->ac_pred = get_bits1(&s->gb);
de6d9b64
FB
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
781static 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 */
612476ef
A
833 if (get_bits1(&s->gb) == 0) {
834 if (get_bits1(&s->gb) == 0) {
de6d9b64 835 /* third escape */
612476ef 836 last = get_bits1(&s->gb);
de6d9b64
FB
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;
612476ef 849 if (get_bits1(&s->gb))
de6d9b64
FB
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];
612476ef 861 if (get_bits1(&s->gb))
de6d9b64
FB
862 level = -level;
863 }
864 } else {
865 run = rl->table_run[code];
866 level = rl->table_level[code];
867 last = code >= rl->last;
612476ef 868 if (get_bits1(&s->gb))
de6d9b64
FB
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
892static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
893{
894 int level, pred;
98be975d 895 INT16 *dc_val;
de6d9b64
FB
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);
612476ef 907 if (get_bits1(&s->gb))
de6d9b64
FB
908 level = -level;
909 } else if (level != 0) {
612476ef 910 if (get_bits1(&s->gb))
de6d9b64
FB
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
927static 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}