Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 05f361f0

History | View | Annotate | Download (25.4 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

    
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
}