Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ badaf88e

History | View | Annotate | Download (26.1 KB)

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
}