Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ ceaaf78b

History | View | Annotate | Download (60.5 KB)

1
/*
2
 * MSMPEG4 backend for ffmpeg encoder and decoder
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24

    
25
/**
26
 * @file msmpeg4.c
27
 * MSMPEG4 backend for ffmpeg encoder and decoder.
28
 */
29

    
30
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33
#include "msmpeg4.h"
34

    
35
/*
36
 * You can also call this codec : MPEG4 with a twist !
37
 *
38
 * TODO:
39
 *        - (encoding) select best mv table (two choices)
40
 *        - (encoding) select best vlc/dc table
41
 */
42
//#define DEBUG
43

    
44
#define DC_VLC_BITS 9
45
#define CBPY_VLC_BITS 6
46
#define V1_INTRA_CBPC_VLC_BITS 6
47
#define V1_INTER_CBPC_VLC_BITS 6
48
#define V2_INTRA_CBPC_VLC_BITS 3
49
#define V2_MB_TYPE_VLC_BITS 7
50
#define MV_VLC_BITS 9
51
#define V2_MV_VLC_BITS 9
52
#define TEX_VLC_BITS 9
53

    
54
#define II_BITRATE 128*1024
55
#define MBAC_BITRATE 50*1024
56

    
57
#define DEFAULT_INTER_INDEX 3
58

    
59
static uint32_t v2_dc_lum_table[512][2];
60
static uint32_t v2_dc_chroma_table[512][2];
61

    
62
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
63
static void init_h263_dc_for_msmpeg4(void);
64
static inline void msmpeg4_memsetw(short *tab, int val, int n);
65
#ifdef CONFIG_ENCODERS
66
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
67
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
68
#endif //CONFIG_ENCODERS
69
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
70
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
71

    
72
/* vc1 externs */
73
extern const uint8_t wmv3_dc_scale_table[32];
74

    
75
#ifdef DEBUG
76
int intra_count = 0;
77
int frame_count = 0;
78
#endif
79

    
80
#include "msmpeg4data.h"
81

    
82
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if it is not references
83
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
84
#endif //CONFIG_ENCODERS
85

    
86
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
87

    
88
static void common_init(MpegEncContext * s)
89
{
90
    static int initialized=0;
91

    
92
    switch(s->msmpeg4_version){
93
    case 1:
94
    case 2:
95
        s->y_dc_scale_table=
96
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
97
        break;
98
    case 3:
99
        if(s->workaround_bugs){
100
            s->y_dc_scale_table= old_ff_y_dc_scale_table;
101
            s->c_dc_scale_table= old_ff_c_dc_scale_table;
102
        } else{
103
            s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
104
            s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
105
        }
106
        break;
107
    case 4:
108
    case 5:
109
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
110
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
111
        break;
112
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
113
    case 6:
114
        s->y_dc_scale_table= wmv3_dc_scale_table;
115
        s->c_dc_scale_table= wmv3_dc_scale_table;
116
        break;
117
#endif
118

    
119
    }
120

    
121

    
122
    if(s->msmpeg4_version>=4){
123
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
124
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
125
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
126
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
127
    }
128
    //Note the default tables are set in common_init in mpegvideo.c
129

    
130
    if(!initialized){
131
        initialized=1;
132

    
133
        init_h263_dc_for_msmpeg4();
134
    }
135
}
136

    
137
#ifdef CONFIG_ENCODERS
138

    
139
/* build the table which associate a (x,y) motion vector to a vlc */
140
static void init_mv_table(MVTable *tab)
141
{
142
    int i, x, y;
143

    
144
    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
145
    /* mark all entries as not used */
146
    for(i=0;i<4096;i++)
147
        tab->table_mv_index[i] = tab->n;
148

    
149
    for(i=0;i<tab->n;i++) {
150
        x = tab->table_mvx[i];
151
        y = tab->table_mvy[i];
152
        tab->table_mv_index[(x << 6) | y] = i;
153
    }
154
}
155

    
156
void ff_msmpeg4_code012(PutBitContext *pb, int n)
157
{
158
    if (n == 0) {
159
        put_bits(pb, 1, 0);
160
    } else {
161
        put_bits(pb, 1, 1);
162
        put_bits(pb, 1, (n >= 2));
163
    }
164
}
165

    
166
void ff_msmpeg4_encode_init(MpegEncContext *s)
167
{
168
    static int init_done=0;
169
    int i;
170

    
171
    common_init(s);
172
    if(s->msmpeg4_version>=4){
173
        s->min_qcoeff= -255;
174
        s->max_qcoeff=  255;
175
    }
176

    
177
    if (!init_done) {
178
        /* init various encoding tables */
179
        init_done = 1;
180
        init_mv_table(&mv_tables[0]);
181
        init_mv_table(&mv_tables[1]);
182
        for(i=0;i<NB_RL_TABLES;i++)
183
            init_rl(&rl_table[i], static_rl_table_store[i]);
184

    
185
        for(i=0; i<NB_RL_TABLES; i++){
186
            int level;
187
            for(level=0; level<=MAX_LEVEL; level++){
188
                int run;
189
                for(run=0; run<=MAX_RUN; run++){
190
                    int last;
191
                    for(last=0; last<2; last++){
192
                        rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
193
                    }
194
                }
195
            }
196
        }
197
    }
198
}
199

    
200
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
201
    int size=0;
202
    int code;
203
    int run_diff= intra ? 0 : 1;
204

    
205
    code = get_rl_index(rl, last, run, level);
206
    size+= rl->table_vlc[code][1];
207
    if (code == rl->n) {
208
        int level1, run1;
209

    
210
        level1 = level - rl->max_level[last][run];
211
        if (level1 < 1)
212
            goto esc2;
213
        code = get_rl_index(rl, last, run, level1);
214
        if (code == rl->n) {
215
            esc2:
216
            size++;
217
            if (level > MAX_LEVEL)
218
                goto esc3;
219
            run1 = run - rl->max_run[last][level] - run_diff;
220
            if (run1 < 0)
221
                goto esc3;
222
            code = get_rl_index(rl, last, run1, level);
223
            if (code == rl->n) {
224
            esc3:
225
                /* third escape */
226
                size+=1+1+6+8;
227
            } else {
228
                /* second escape */
229
                size+= 1+1+ rl->table_vlc[code][1];
230
            }
231
        } else {
232
            /* first escape */
233
            size+= 1+1+ rl->table_vlc[code][1];
234
        }
235
    } else {
236
        size++;
237
    }
238
    return size;
239
}
240

    
241
void ff_find_best_tables(MpegEncContext * s)
242
{
243
    int i;
244
    int best       =-1, best_size       =9999999;
245
    int chroma_best=-1, best_chroma_size=9999999;
246

    
247
    for(i=0; i<3; i++){
248
        int level;
249
        int chroma_size=0;
250
        int size=0;
251

    
252
        if(i>0){// ;)
253
            size++;
254
            chroma_size++;
255
        }
256
        for(level=0; level<=MAX_LEVEL; level++){
257
            int run;
258
            for(run=0; run<=MAX_RUN; run++){
259
                int last;
260
                const int last_size= size + chroma_size;
261
                for(last=0; last<2; last++){
262
                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
263
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
264
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
265

    
266
                    if(s->pict_type==FF_I_TYPE){
267
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
268
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
269
                    }else{
270
                        size+=        intra_luma_count  *rl_length[i  ][level][run][last]
271
                                     +intra_chroma_count*rl_length[i+3][level][run][last]
272
                                     +inter_count       *rl_length[i+3][level][run][last];
273
                    }
274
                }
275
                if(last_size == size+chroma_size) break;
276
            }
277
        }
278
        if(size<best_size){
279
            best_size= size;
280
            best= i;
281
        }
282
        if(chroma_size<best_chroma_size){
283
            best_chroma_size= chroma_size;
284
            chroma_best= i;
285
        }
286
    }
287

    
288
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
289
//           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
290

    
291
    if(s->pict_type==FF_P_TYPE) chroma_best= best;
292

    
293
    memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
294

    
295
    s->rl_table_index       =        best;
296
    s->rl_chroma_table_index= chroma_best;
297

    
298
    if(s->pict_type != s->last_non_b_pict_type){
299
        s->rl_table_index= 2;
300
        if(s->pict_type==FF_I_TYPE)
301
            s->rl_chroma_table_index= 1;
302
        else
303
            s->rl_chroma_table_index= 2;
304
    }
305

    
306
}
307

    
308
/* write MSMPEG4 compatible frame header */
309
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
310
{
311
    ff_find_best_tables(s);
312

    
313
    align_put_bits(&s->pb);
314
    put_bits(&s->pb, 2, s->pict_type - 1);
315

    
316
    put_bits(&s->pb, 5, s->qscale);
317
    if(s->msmpeg4_version<=2){
318
        s->rl_table_index = 2;
319
        s->rl_chroma_table_index = 2;
320
    }
321

    
322
    s->dc_table_index = 1;
323
    s->mv_table_index = 1; /* only if P frame */
324
    s->use_skip_mb_code = 1; /* only if P frame */
325
    s->per_mb_rl_table = 0;
326
    if(s->msmpeg4_version==4)
327
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
328
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
329

    
330
    if (s->pict_type == FF_I_TYPE) {
331
        s->slice_height= s->mb_height/1;
332
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
333

    
334
        if(s->msmpeg4_version==4){
335
            msmpeg4_encode_ext_header(s);
336
            if(s->bit_rate>MBAC_BITRATE)
337
                put_bits(&s->pb, 1, s->per_mb_rl_table);
338
        }
339

    
340
        if(s->msmpeg4_version>2){
341
            if(!s->per_mb_rl_table){
342
                ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
343
                ff_msmpeg4_code012(&s->pb, s->rl_table_index);
344
            }
345

    
346
            put_bits(&s->pb, 1, s->dc_table_index);
347
        }
348
    } else {
349
        put_bits(&s->pb, 1, s->use_skip_mb_code);
350

    
351
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
352
            put_bits(&s->pb, 1, s->per_mb_rl_table);
353

    
354
        if(s->msmpeg4_version>2){
355
            if(!s->per_mb_rl_table)
356
                ff_msmpeg4_code012(&s->pb, s->rl_table_index);
357

    
358
            put_bits(&s->pb, 1, s->dc_table_index);
359

    
360
            put_bits(&s->pb, 1, s->mv_table_index);
361
        }
362
    }
363

    
364
    s->esc3_level_length= 0;
365
    s->esc3_run_length= 0;
366

    
367
#ifdef DEBUG
368
    intra_count = 0;
369
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
370
#endif
371
}
372

    
373
void msmpeg4_encode_ext_header(MpegEncContext * s)
374
{
375
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
376

    
377
        put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
378

    
379
        if(s->msmpeg4_version>=3)
380
            put_bits(&s->pb, 1, s->flipflop_rounding);
381
        else
382
            assert(s->flipflop_rounding==0);
383
}
384

    
385
#endif //CONFIG_ENCODERS
386

    
387
/* predict coded block */
388
int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
389
{
390
    int xy, wrap, pred, a, b, c;
391

    
392
    xy = s->block_index[n];
393
    wrap = s->b8_stride;
394

    
395
    /* B C
396
     * A X
397
     */
398
    a = s->coded_block[xy - 1       ];
399
    b = s->coded_block[xy - 1 - wrap];
400
    c = s->coded_block[xy     - wrap];
401

    
402
    if (b == c) {
403
        pred = a;
404
    } else {
405
        pred = c;
406
    }
407

    
408
    /* store value */
409
    *coded_block_ptr = &s->coded_block[xy];
410

    
411
    return pred;
412
}
413

    
414
#ifdef CONFIG_ENCODERS
415

    
416
void ff_msmpeg4_encode_motion(MpegEncContext * s,
417
                                  int mx, int my)
418
{
419
    int code;
420
    MVTable *mv;
421

    
422
    /* modulo encoding */
423
    /* WARNING : you cannot reach all the MVs even with the modulo
424
       encoding. This is a somewhat strange compromise they took !!!  */
425
    if (mx <= -64)
426
        mx += 64;
427
    else if (mx >= 64)
428
        mx -= 64;
429
    if (my <= -64)
430
        my += 64;
431
    else if (my >= 64)
432
        my -= 64;
433

    
434
    mx += 32;
435
    my += 32;
436
#if 0
437
    if ((unsigned)mx >= 64 ||
438
        (unsigned)my >= 64)
439
        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
440
#endif
441
    mv = &mv_tables[s->mv_table_index];
442

    
443
    code = mv->table_mv_index[(mx << 6) | my];
444
    put_bits(&s->pb,
445
             mv->table_mv_bits[code],
446
             mv->table_mv_code[code]);
447
    if (code == mv->n) {
448
        /* escape : code literally */
449
        put_bits(&s->pb, 6, mx);
450
        put_bits(&s->pb, 6, my);
451
    }
452
}
453

    
454
void ff_msmpeg4_handle_slices(MpegEncContext *s){
455
    if (s->mb_x == 0) {
456
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
457
            if(s->msmpeg4_version < 4){
458
                ff_mpeg4_clean_buffers(s);
459
            }
460
            s->first_slice_line = 1;
461
        } else {
462
            s->first_slice_line = 0;
463
        }
464
    }
465
}
466

    
467
void msmpeg4_encode_mb(MpegEncContext * s,
468
                       DCTELEM block[6][64],
469
                       int motion_x, int motion_y)
470
{
471
    int cbp, coded_cbp, i;
472
    int pred_x, pred_y;
473
    uint8_t *coded_block;
474

    
475
    ff_msmpeg4_handle_slices(s);
476

    
477
    if (!s->mb_intra) {
478
        /* compute cbp */
479
        cbp = 0;
480
        for (i = 0; i < 6; i++) {
481
            if (s->block_last_index[i] >= 0)
482
                cbp |= 1 << (5 - i);
483
        }
484
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
485
            /* skip macroblock */
486
            put_bits(&s->pb, 1, 1);
487
            s->last_bits++;
488
            s->misc_bits++;
489
            s->skip_count++;
490

    
491
            return;
492
        }
493
        if (s->use_skip_mb_code)
494
            put_bits(&s->pb, 1, 0);     /* mb coded */
495

    
496
        if(s->msmpeg4_version<=2){
497
            put_bits(&s->pb,
498
                     v2_mb_type[cbp&3][1],
499
                     v2_mb_type[cbp&3][0]);
500
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
501
            else             coded_cbp= cbp;
502

    
503
            put_bits(&s->pb,
504
                     cbpy_tab[coded_cbp>>2][1],
505
                     cbpy_tab[coded_cbp>>2][0]);
506

    
507
            s->misc_bits += get_bits_diff(s);
508

    
509
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
510
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
511
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
512
        }else{
513
            put_bits(&s->pb,
514
                     table_mb_non_intra[cbp + 64][1],
515
                     table_mb_non_intra[cbp + 64][0]);
516

    
517
            s->misc_bits += get_bits_diff(s);
518

    
519
            /* motion vector */
520
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
521
            ff_msmpeg4_encode_motion(s, motion_x - pred_x,
522
                                  motion_y - pred_y);
523
        }
524

    
525
        s->mv_bits += get_bits_diff(s);
526

    
527
        for (i = 0; i < 6; i++) {
528
            ff_msmpeg4_encode_block(s, block[i], i);
529
        }
530
        s->p_tex_bits += get_bits_diff(s);
531
    } else {
532
        /* compute cbp */
533
        cbp = 0;
534
        coded_cbp = 0;
535
        for (i = 0; i < 6; i++) {
536
            int val, pred;
537
            val = (s->block_last_index[i] >= 1);
538
            cbp |= val << (5 - i);
539
            if (i < 4) {
540
                /* predict value for close blocks only for luma */
541
                pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
542
                *coded_block = val;
543
                val = val ^ pred;
544
            }
545
            coded_cbp |= val << (5 - i);
546
        }
547
#if 0
548
        if (coded_cbp)
549
            printf("cbp=%x %x\n", cbp, coded_cbp);
550
#endif
551

    
552
        if(s->msmpeg4_version<=2){
553
            if (s->pict_type == FF_I_TYPE) {
554
                put_bits(&s->pb,
555
                         v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
556
            } else {
557
                if (s->use_skip_mb_code)
558
                    put_bits(&s->pb, 1, 0);     /* mb coded */
559
                put_bits(&s->pb,
560
                         v2_mb_type[(cbp&3) + 4][1],
561
                         v2_mb_type[(cbp&3) + 4][0]);
562
            }
563
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
564
            put_bits(&s->pb,
565
                     cbpy_tab[cbp>>2][1],
566
                     cbpy_tab[cbp>>2][0]);
567
        }else{
568
            if (s->pict_type == FF_I_TYPE) {
569
                put_bits(&s->pb,
570
                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
571
            } else {
572
                if (s->use_skip_mb_code)
573
                    put_bits(&s->pb, 1, 0);     /* mb coded */
574
                put_bits(&s->pb,
575
                         table_mb_non_intra[cbp][1],
576
                         table_mb_non_intra[cbp][0]);
577
            }
578
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
579
            if(s->inter_intra_pred){
580
                s->h263_aic_dir=0;
581
                put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
582
            }
583
        }
584
        s->misc_bits += get_bits_diff(s);
585

    
586
        for (i = 0; i < 6; i++) {
587
            ff_msmpeg4_encode_block(s, block[i], i);
588
        }
589
        s->i_tex_bits += get_bits_diff(s);
590
        s->i_count++;
591
    }
592
}
593

    
594
#endif //CONFIG_ENCODERS
595

    
596
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
597
                                    int32_t **dc_val_ptr)
598
{
599
    int i;
600

    
601
    if (n < 4) {
602
        i= 0;
603
    } else {
604
        i= n-3;
605
    }
606

    
607
    *dc_val_ptr= &s->last_dc[i];
608
    return s->last_dc[i];
609
}
610

    
611
static int get_dc(uint8_t *src, int stride, int scale)
612
{
613
    int y;
614
    int sum=0;
615
    for(y=0; y<8; y++){
616
        int x;
617
        for(x=0; x<8; x++){
618
            sum+=src[x + y*stride];
619
        }
620
    }
621
    return FASTDIV((sum + (scale>>1)), scale);
622
}
623

    
624
/* dir = 0: left, dir = 1: top prediction */
625
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
626
                             int16_t **dc_val_ptr, int *dir_ptr)
627
{
628
    int a, b, c, wrap, pred, scale;
629
    int16_t *dc_val;
630

    
631
    /* find prediction */
632
    if (n < 4) {
633
        scale = s->y_dc_scale;
634
    } else {
635
        scale = s->c_dc_scale;
636
    }
637

    
638
    wrap = s->block_wrap[n];
639
    dc_val= s->dc_val[0] + s->block_index[n];
640

    
641
    /* B C
642
     * A X
643
     */
644
    a = dc_val[ - 1];
645
    b = dc_val[ - 1 - wrap];
646
    c = dc_val[ - wrap];
647

    
648
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
649
        b=c=1024;
650
    }
651

    
652
    /* XXX: the following solution consumes divisions, but it does not
653
       necessitate to modify mpegvideo.c. The problem comes from the
654
       fact they decided to store the quantized DC (which would lead
655
       to problems if Q could vary !) */
656
#if (defined(ARCH_X86)) && !defined PIC
657
    asm volatile(
658
        "movl %3, %%eax         \n\t"
659
        "shrl $1, %%eax         \n\t"
660
        "addl %%eax, %2         \n\t"
661
        "addl %%eax, %1         \n\t"
662
        "addl %0, %%eax         \n\t"
663
        "mull %4                \n\t"
664
        "movl %%edx, %0         \n\t"
665
        "movl %1, %%eax         \n\t"
666
        "mull %4                \n\t"
667
        "movl %%edx, %1         \n\t"
668
        "movl %2, %%eax         \n\t"
669
        "mull %4                \n\t"
670
        "movl %%edx, %2         \n\t"
671
        : "+b" (a), "+c" (b), "+D" (c)
672
        : "g" (scale), "S" (ff_inverse[scale])
673
        : "%eax", "%edx"
674
    );
675
#else
676
    /* #elif defined (ARCH_ALPHA) */
677
    /* Divisions are extremely costly on Alpha; optimize the most
678
       common case. But they are costly everywhere...
679
     */
680
    if (scale == 8) {
681
        a = (a + (8 >> 1)) / 8;
682
        b = (b + (8 >> 1)) / 8;
683
        c = (c + (8 >> 1)) / 8;
684
    } else {
685
        a = FASTDIV((a + (scale >> 1)), scale);
686
        b = FASTDIV((b + (scale >> 1)), scale);
687
        c = FASTDIV((c + (scale >> 1)), scale);
688
    }
689
#endif
690
    /* XXX: WARNING: they did not choose the same test as MPEG4. This
691
       is very important ! */
692
    if(s->msmpeg4_version>3){
693
        if(s->inter_intra_pred){
694
            uint8_t *dest;
695
            int wrap;
696

    
697
            if(n==1){
698
                pred=a;
699
                *dir_ptr = 0;
700
            }else if(n==2){
701
                pred=c;
702
                *dir_ptr = 1;
703
            }else if(n==3){
704
                if (abs(a - b) < abs(b - c)) {
705
                    pred = c;
706
                    *dir_ptr = 1;
707
                } else {
708
                    pred = a;
709
                    *dir_ptr = 0;
710
                }
711
            }else{
712
                if(n<4){
713
                    wrap= s->linesize;
714
                    dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
715
                }else{
716
                    wrap= s->uvlinesize;
717
                    dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
718
                }
719
                if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
720
                else           a= get_dc(dest-8, wrap, scale*8);
721
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
722
                else           c= get_dc(dest-8*wrap, wrap, scale*8);
723

    
724
                if (s->h263_aic_dir==0) {
725
                    pred= a;
726
                    *dir_ptr = 0;
727
                }else if (s->h263_aic_dir==1) {
728
                    if(n==0){
729
                        pred= c;
730
                        *dir_ptr = 1;
731
                    }else{
732
                        pred= a;
733
                        *dir_ptr = 0;
734
                    }
735
                }else if (s->h263_aic_dir==2) {
736
                    if(n==0){
737
                        pred= a;
738
                        *dir_ptr = 0;
739
                    }else{
740
                        pred= c;
741
                        *dir_ptr = 1;
742
                    }
743
                } else {
744
                    pred= c;
745
                    *dir_ptr = 1;
746
                }
747
            }
748
        }else{
749
            if (abs(a - b) < abs(b - c)) {
750
                pred = c;
751
                *dir_ptr = 1;
752
            } else {
753
                pred = a;
754
                *dir_ptr = 0;
755
            }
756
        }
757
    }else{
758
        if (abs(a - b) <= abs(b - c)) {
759
            pred = c;
760
            *dir_ptr = 1;
761
        } else {
762
            pred = a;
763
            *dir_ptr = 0;
764
        }
765
    }
766

    
767
    /* update predictor */
768
    *dc_val_ptr = &dc_val[0];
769
    return pred;
770
}
771

    
772
#define DC_MAX 119
773

    
774
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
775
{
776
    int sign, code;
777
    int pred, extquant;
778
    int extrabits = 0;
779

    
780
    if(s->msmpeg4_version==1){
781
        int32_t *dc_val;
782
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
783

    
784
        /* update predictor */
785
        *dc_val= level;
786
    }else{
787
        int16_t *dc_val;
788
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
789

    
790
        /* update predictor */
791
        if (n < 4) {
792
            *dc_val = level * s->y_dc_scale;
793
        } else {
794
            *dc_val = level * s->c_dc_scale;
795
        }
796
    }
797

    
798
    /* do the prediction */
799
    level -= pred;
800

    
801
    if(s->msmpeg4_version<=2){
802
        if (n < 4) {
803
            put_bits(&s->pb,
804
                     v2_dc_lum_table[level+256][1],
805
                     v2_dc_lum_table[level+256][0]);
806
        }else{
807
            put_bits(&s->pb,
808
                     v2_dc_chroma_table[level+256][1],
809
                     v2_dc_chroma_table[level+256][0]);
810
        }
811
    }else{
812
        sign = 0;
813
        if (level < 0) {
814
            level = -level;
815
            sign = 1;
816
        }
817
        code = level;
818
        if (code > DC_MAX)
819
            code = DC_MAX;
820
        else if( s->msmpeg4_version>=6 ) {
821
            if( s->qscale == 1 ) {
822
                extquant = (level + 3) & 0x3;
823
                code  = ((level+3)>>2);
824
            } else if( s->qscale == 2 ) {
825
                extquant = (level + 1) & 0x1;
826
                code  = ((level+1)>>1);
827
            }
828
        }
829

    
830
        if (s->dc_table_index == 0) {
831
            if (n < 4) {
832
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
833
            } else {
834
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
835
            }
836
        } else {
837
            if (n < 4) {
838
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
839
            } else {
840
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
841
            }
842
        }
843

    
844
        if(s->msmpeg4_version>=6 && s->qscale<=2)
845
            extrabits = 3 - s->qscale;
846

    
847
        if (code == DC_MAX)
848
            put_bits(&s->pb, 8 + extrabits, level);
849
        else if(extrabits > 0)//== VC1 && s->qscale<=2
850
            put_bits(&s->pb, extrabits, extquant);
851

    
852
        if (level != 0) {
853
            put_bits(&s->pb, 1, sign);
854
        }
855
    }
856
}
857

    
858
/* Encoding of a block. Very similar to MPEG4 except for a different
859
   escape coding (same as H263) and more vlc tables.
860
 */
861
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
862
{
863
    int level, run, last, i, j, last_index;
864
    int last_non_zero, sign, slevel;
865
    int code, run_diff, dc_pred_dir;
866
    const RLTable *rl;
867
    const uint8_t *scantable;
868

    
869
    if (s->mb_intra) {
870
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
871
        i = 1;
872
        if (n < 4) {
873
            rl = &rl_table[s->rl_table_index];
874
        } else {
875
            rl = &rl_table[3 + s->rl_chroma_table_index];
876
        }
877
        run_diff = s->msmpeg4_version>=4;
878
        scantable= s->intra_scantable.permutated;
879
    } else {
880
        i = 0;
881
        rl = &rl_table[3 + s->rl_table_index];
882
        if(s->msmpeg4_version<=2)
883
            run_diff = 0;
884
        else
885
            run_diff = 1;
886
        scantable= s->inter_scantable.permutated;
887
    }
888

    
889
    /* recalculate block_last_index for M$ wmv1 */
890
    if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
891
        for(last_index=63; last_index>=0; last_index--){
892
            if(block[scantable[last_index]]) break;
893
        }
894
        s->block_last_index[n]= last_index;
895
    }else
896
        last_index = s->block_last_index[n];
897
    /* AC coefs */
898
    last_non_zero = i - 1;
899
    for (; i <= last_index; i++) {
900
        j = scantable[i];
901
        level = block[j];
902
        if (level) {
903
            run = i - last_non_zero - 1;
904
            last = (i == last_index);
905
            sign = 0;
906
            slevel = level;
907
            if (level < 0) {
908
                sign = 1;
909
                level = -level;
910
            }
911

    
912
            if(level<=MAX_LEVEL && run<=MAX_RUN){
913
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
914
            }
915
#if 0
916
else
917
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
918
#endif
919
            code = get_rl_index(rl, last, run, level);
920
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
921
            if (code == rl->n) {
922
                int level1, run1;
923

    
924
                level1 = level - rl->max_level[last][run];
925
                if (level1 < 1)
926
                    goto esc2;
927
                code = get_rl_index(rl, last, run, level1);
928
                if (code == rl->n) {
929
                esc2:
930
                    put_bits(&s->pb, 1, 0);
931
                    if (level > MAX_LEVEL)
932
                        goto esc3;
933
                    run1 = run - rl->max_run[last][level] - run_diff;
934
                    if (run1 < 0)
935
                        goto esc3;
936
                    code = get_rl_index(rl, last, run1+1, level);
937
                    if (s->msmpeg4_version == 4 && code == rl->n)
938
                        goto esc3;
939
                    code = get_rl_index(rl, last, run1, level);
940
                    if (code == rl->n) {
941
                    esc3:
942
                        /* third escape */
943
                        put_bits(&s->pb, 1, 0);
944
                        put_bits(&s->pb, 1, last);
945
                        if(s->msmpeg4_version>=4){
946
                            if(s->esc3_level_length==0){
947
                                s->esc3_level_length=8;
948
                                s->esc3_run_length= 6;
949
                                //ESCLVLSZ + ESCRUNSZ
950
                                if(s->qscale<8)
951
                                    put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
952
                                else
953
                                    put_bits(&s->pb, 8, 3);
954
                            }
955
                            put_bits(&s->pb, s->esc3_run_length, run);
956
                            put_bits(&s->pb, 1, sign);
957
                            put_bits(&s->pb, s->esc3_level_length, level);
958
                        }else{
959
                            put_bits(&s->pb, 6, run);
960
                            put_bits(&s->pb, 8, slevel & 0xff);
961
                        }
962
                    } else {
963
                        /* second escape */
964
                        put_bits(&s->pb, 1, 1);
965
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
966
                        put_bits(&s->pb, 1, sign);
967
                    }
968
                } else {
969
                    /* first escape */
970
                    put_bits(&s->pb, 1, 1);
971
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
972
                    put_bits(&s->pb, 1, sign);
973
                }
974
            } else {
975
                put_bits(&s->pb, 1, sign);
976
            }
977
            last_non_zero = i;
978
        }
979
    }
980
}
981

    
982
/****************************************/
983
/* decoding stuff */
984

    
985
VLC ff_mb_non_intra_vlc[4];
986
static VLC v2_dc_lum_vlc;
987
static VLC v2_dc_chroma_vlc;
988
static VLC cbpy_vlc;
989
static VLC v2_intra_cbpc_vlc;
990
static VLC v2_mb_type_vlc;
991
static VLC v2_mv_vlc;
992
static VLC v1_intra_cbpc_vlc;
993
static VLC v1_inter_cbpc_vlc;
994
VLC ff_inter_intra_vlc;
995

    
996
/* This table is practically identical to the one from h263
997
 * except that it is inverted. */
998
static void init_h263_dc_for_msmpeg4(void)
999
{
1000
        int level, uni_code, uni_len;
1001

    
1002
        for(level=-256; level<256; level++){
1003
            int size, v, l;
1004
            /* find number of bits */
1005
            size = 0;
1006
            v = abs(level);
1007
            while (v) {
1008
                v >>= 1;
1009
                    size++;
1010
            }
1011

    
1012
            if (level < 0)
1013
                l= (-level) ^ ((1 << size) - 1);
1014
            else
1015
                l= level;
1016

    
1017
            /* luminance h263 */
1018
            uni_code= DCtab_lum[size][0];
1019
            uni_len = DCtab_lum[size][1];
1020
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1021

    
1022
            if (size > 0) {
1023
                uni_code<<=size; uni_code|=l;
1024
                uni_len+=size;
1025
                if (size > 8){
1026
                    uni_code<<=1; uni_code|=1;
1027
                    uni_len++;
1028
                }
1029
            }
1030
            v2_dc_lum_table[level+256][0]= uni_code;
1031
            v2_dc_lum_table[level+256][1]= uni_len;
1032

    
1033
            /* chrominance h263 */
1034
            uni_code= DCtab_chrom[size][0];
1035
            uni_len = DCtab_chrom[size][1];
1036
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1037

    
1038
            if (size > 0) {
1039
                uni_code<<=size; uni_code|=l;
1040
                uni_len+=size;
1041
                if (size > 8){
1042
                    uni_code<<=1; uni_code|=1;
1043
                    uni_len++;
1044
                }
1045
            }
1046
            v2_dc_chroma_table[level+256][0]= uni_code;
1047
            v2_dc_chroma_table[level+256][1]= uni_len;
1048

    
1049
        }
1050
}
1051

    
1052
/* init all vlc decoding tables */
1053
int ff_msmpeg4_decode_init(MpegEncContext *s)
1054
{
1055
    static int done = 0;
1056
    int i;
1057
    MVTable *mv;
1058

    
1059
    common_init(s);
1060

    
1061
    if (!done) {
1062
        done = 1;
1063

    
1064
        for(i=0;i<NB_RL_TABLES;i++) {
1065
            init_rl(&rl_table[i], static_rl_table_store[i]);
1066
        }
1067
        INIT_VLC_RL(rl_table[0], 642);
1068
        INIT_VLC_RL(rl_table[1], 1104);
1069
        INIT_VLC_RL(rl_table[2], 554);
1070
        INIT_VLC_RL(rl_table[3], 940);
1071
        INIT_VLC_RL(rl_table[4], 962);
1072
        INIT_VLC_RL(rl_table[5], 554);
1073
        for(i=0;i<2;i++) {
1074
            mv = &mv_tables[i];
1075
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1076
                     mv->table_mv_bits, 1, 1,
1077
                     mv->table_mv_code, 2, 2, 1);
1078
        }
1079

    
1080
        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1081
                 &ff_table0_dc_lum[0][1], 8, 4,
1082
                 &ff_table0_dc_lum[0][0], 8, 4, 1);
1083
        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1084
                 &ff_table0_dc_chroma[0][1], 8, 4,
1085
                 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1086
        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1087
                 &ff_table1_dc_lum[0][1], 8, 4,
1088
                 &ff_table1_dc_lum[0][0], 8, 4, 1);
1089
        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1090
                 &ff_table1_dc_chroma[0][1], 8, 4,
1091
                 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1092

    
1093
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1094
                 &v2_dc_lum_table[0][1], 8, 4,
1095
                 &v2_dc_lum_table[0][0], 8, 4, 1);
1096
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1097
                 &v2_dc_chroma_table[0][1], 8, 4,
1098
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
1099

    
1100
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1101
                 &cbpy_tab[0][1], 2, 1,
1102
                 &cbpy_tab[0][0], 2, 1, 1);
1103
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1104
                 &v2_intra_cbpc[0][1], 2, 1,
1105
                 &v2_intra_cbpc[0][0], 2, 1, 1);
1106
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1107
                 &v2_mb_type[0][1], 2, 1,
1108
                 &v2_mb_type[0][0], 2, 1, 1);
1109
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1110
                 &mvtab[0][1], 2, 1,
1111
                 &mvtab[0][0], 2, 1, 1);
1112

    
1113
        for(i=0; i<4; i++){
1114
            init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1115
                     &wmv2_inter_table[i][0][1], 8, 4,
1116
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1117
        }
1118

    
1119
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1120
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
1121
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1122

    
1123
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1124
                 intra_MCBPC_bits, 1, 1,
1125
                 intra_MCBPC_code, 1, 1, 1);
1126
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1127
                 inter_MCBPC_bits, 1, 1,
1128
                 inter_MCBPC_code, 1, 1, 1);
1129

    
1130
        init_vlc(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1131
                 &table_inter_intra[0][1], 2, 1,
1132
                 &table_inter_intra[0][0], 2, 1, 1);
1133
    }
1134

    
1135
    switch(s->msmpeg4_version){
1136
    case 1:
1137
    case 2:
1138
        s->decode_mb= msmpeg4v12_decode_mb;
1139
        break;
1140
    case 3:
1141
    case 4:
1142
        s->decode_mb= msmpeg4v34_decode_mb;
1143
        break;
1144
    case 5:
1145
        if (ENABLE_WMV2_DECODER)
1146
            s->decode_mb= ff_wmv2_decode_mb;
1147
    case 6:
1148
        //FIXME + TODO VC1 decode mb
1149
        break;
1150
    }
1151

    
1152
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1153

    
1154
    return 0;
1155
}
1156

    
1157
int msmpeg4_decode_picture_header(MpegEncContext * s)
1158
{
1159
    int code;
1160

    
1161
#if 0
1162
{
1163
int i;
1164
for(i=0; i<s->gb.size_in_bits; i++)
1165
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1166
//    get_bits1(&s->gb);
1167
av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1168
return -1;
1169
}
1170
#endif
1171

    
1172
    if(s->msmpeg4_version==1){
1173
        int start_code, num;
1174
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1175
        if(start_code!=0x00000100){
1176
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1177
            return -1;
1178
        }
1179

    
1180
        num= get_bits(&s->gb, 5); // frame number */
1181
    }
1182

    
1183
    s->pict_type = get_bits(&s->gb, 2) + 1;
1184
    if (s->pict_type != FF_I_TYPE &&
1185
        s->pict_type != FF_P_TYPE){
1186
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1187
        return -1;
1188
    }
1189
#if 0
1190
{
1191
    static int had_i=0;
1192
    if(s->pict_type == FF_I_TYPE) had_i=1;
1193
    if(!had_i) return -1;
1194
}
1195
#endif
1196
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1197
    if(s->qscale==0){
1198
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1199
        return -1;
1200
    }
1201

    
1202
    if (s->pict_type == FF_I_TYPE) {
1203
        code = get_bits(&s->gb, 5);
1204
        if(s->msmpeg4_version==1){
1205
            if(code==0 || code>s->mb_height){
1206
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1207
                return -1;
1208
            }
1209

    
1210
            s->slice_height = code;
1211
        }else{
1212
            /* 0x17: one slice, 0x18: two slices, ... */
1213
            if (code < 0x17){
1214
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1215
                return -1;
1216
            }
1217

    
1218
            s->slice_height = s->mb_height / (code - 0x16);
1219
        }
1220

    
1221
        switch(s->msmpeg4_version){
1222
        case 1:
1223
        case 2:
1224
            s->rl_chroma_table_index = 2;
1225
            s->rl_table_index = 2;
1226

    
1227
            s->dc_table_index = 0; //not used
1228
            break;
1229
        case 3:
1230
            s->rl_chroma_table_index = decode012(&s->gb);
1231
            s->rl_table_index = decode012(&s->gb);
1232

    
1233
            s->dc_table_index = get_bits1(&s->gb);
1234
            break;
1235
        case 4:
1236
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1237

    
1238
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1239
            else                           s->per_mb_rl_table= 0;
1240

    
1241
            if(!s->per_mb_rl_table){
1242
                s->rl_chroma_table_index = decode012(&s->gb);
1243
                s->rl_table_index = decode012(&s->gb);
1244
            }
1245

    
1246
            s->dc_table_index = get_bits1(&s->gb);
1247
            s->inter_intra_pred= 0;
1248
            break;
1249
        }
1250
        s->no_rounding = 1;
1251
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1252
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1253
                s->qscale,
1254
                s->rl_chroma_table_index,
1255
                s->rl_table_index,
1256
                s->dc_table_index,
1257
                s->per_mb_rl_table,
1258
                s->slice_height);
1259
    } else {
1260
        switch(s->msmpeg4_version){
1261
        case 1:
1262
        case 2:
1263
            if(s->msmpeg4_version==1)
1264
                s->use_skip_mb_code = 1;
1265
            else
1266
                s->use_skip_mb_code = get_bits1(&s->gb);
1267
            s->rl_table_index = 2;
1268
            s->rl_chroma_table_index = s->rl_table_index;
1269
            s->dc_table_index = 0; //not used
1270
            s->mv_table_index = 0;
1271
            break;
1272
        case 3:
1273
            s->use_skip_mb_code = get_bits1(&s->gb);
1274
            s->rl_table_index = decode012(&s->gb);
1275
            s->rl_chroma_table_index = s->rl_table_index;
1276

    
1277
            s->dc_table_index = get_bits1(&s->gb);
1278

    
1279
            s->mv_table_index = get_bits1(&s->gb);
1280
            break;
1281
        case 4:
1282
            s->use_skip_mb_code = get_bits1(&s->gb);
1283

    
1284
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1285
            else                           s->per_mb_rl_table= 0;
1286

    
1287
            if(!s->per_mb_rl_table){
1288
                s->rl_table_index = decode012(&s->gb);
1289
                s->rl_chroma_table_index = s->rl_table_index;
1290
            }
1291

    
1292
            s->dc_table_index = get_bits1(&s->gb);
1293

    
1294
            s->mv_table_index = get_bits1(&s->gb);
1295
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1296
            break;
1297
        }
1298

    
1299
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1300
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1301
                s->use_skip_mb_code,
1302
                s->rl_table_index,
1303
                s->rl_chroma_table_index,
1304
                s->dc_table_index,
1305
                s->mv_table_index,
1306
                s->per_mb_rl_table,
1307
                s->qscale);
1308

    
1309
        if(s->flipflop_rounding){
1310
            s->no_rounding ^= 1;
1311
        }else{
1312
            s->no_rounding = 0;
1313
        }
1314
    }
1315
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1316

    
1317
    s->esc3_level_length= 0;
1318
    s->esc3_run_length= 0;
1319

    
1320
#ifdef DEBUG
1321
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1322
#endif
1323
    return 0;
1324
}
1325

    
1326
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1327
{
1328
    int left= buf_size*8 - get_bits_count(&s->gb);
1329
    int length= s->msmpeg4_version>=3 ? 17 : 16;
1330
    /* the alt_bitstream reader could read over the end so we need to check it */
1331
    if(left>=length && left<length+8)
1332
    {
1333
        int fps;
1334

    
1335
        fps= get_bits(&s->gb, 5);
1336
        s->bit_rate= get_bits(&s->gb, 11)*1024;
1337
        if(s->msmpeg4_version>=3)
1338
            s->flipflop_rounding= get_bits1(&s->gb);
1339
        else
1340
            s->flipflop_rounding= 0;
1341

    
1342
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1343
    }
1344
    else if(left<length+8)
1345
    {
1346
        s->flipflop_rounding= 0;
1347
        if(s->msmpeg4_version != 2)
1348
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1349
    }
1350
    else
1351
    {
1352
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1353
    }
1354

    
1355
    return 0;
1356
}
1357

    
1358
static inline void msmpeg4_memsetw(short *tab, int val, int n)
1359
{
1360
    int i;
1361
    for(i=0;i<n;i++)
1362
        tab[i] = val;
1363
}
1364

    
1365
#ifdef CONFIG_ENCODERS
1366
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1367
{
1368
    int range, bit_size, sign, code, bits;
1369

    
1370
    if (val == 0) {
1371
        /* zero vector */
1372
        code = 0;
1373
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1374
    } else {
1375
        bit_size = s->f_code - 1;
1376
        range = 1 << bit_size;
1377
        if (val <= -64)
1378
            val += 64;
1379
        else if (val >= 64)
1380
            val -= 64;
1381

    
1382
        if (val >= 0) {
1383
            sign = 0;
1384
        } else {
1385
            val = -val;
1386
            sign = 1;
1387
        }
1388
        val--;
1389
        code = (val >> bit_size) + 1;
1390
        bits = val & (range - 1);
1391

    
1392
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1393
        if (bit_size > 0) {
1394
            put_bits(&s->pb, bit_size, bits);
1395
        }
1396
    }
1397
}
1398
#endif
1399

    
1400
/* This is identical to h263 except that its range is multiplied by 2. */
1401
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1402
{
1403
    int code, val, sign, shift;
1404

    
1405
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1406
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1407
    if (code < 0)
1408
        return 0xffff;
1409

    
1410
    if (code == 0)
1411
        return pred;
1412
    sign = get_bits1(&s->gb);
1413
    shift = f_code - 1;
1414
    val = code;
1415
    if (shift) {
1416
        val = (val - 1) << shift;
1417
        val |= get_bits(&s->gb, shift);
1418
        val++;
1419
    }
1420
    if (sign)
1421
        val = -val;
1422

    
1423
    val += pred;
1424
    if (val <= -64)
1425
        val += 64;
1426
    else if (val >= 64)
1427
        val -= 64;
1428

    
1429
    return val;
1430
}
1431

    
1432
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1433
{
1434
    int cbp, code, i;
1435

    
1436
    if (s->pict_type == FF_P_TYPE) {
1437
        if (s->use_skip_mb_code) {
1438
            if (get_bits1(&s->gb)) {
1439
                /* skip mb */
1440
                s->mb_intra = 0;
1441
                for(i=0;i<6;i++)
1442
                    s->block_last_index[i] = -1;
1443
                s->mv_dir = MV_DIR_FORWARD;
1444
                s->mv_type = MV_TYPE_16X16;
1445
                s->mv[0][0][0] = 0;
1446
                s->mv[0][0][1] = 0;
1447
                s->mb_skipped = 1;
1448
                return 0;
1449
            }
1450
        }
1451

    
1452
        if(s->msmpeg4_version==2)
1453
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1454
        else
1455
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1456
        if(code<0 || code>7){
1457
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1458
            return -1;
1459
        }
1460

    
1461
        s->mb_intra = code >>2;
1462

    
1463
        cbp = code & 0x3;
1464
    } else {
1465
        s->mb_intra = 1;
1466
        if(s->msmpeg4_version==2)
1467
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1468
        else
1469
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1470
        if(cbp<0 || cbp>3){
1471
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1472
            return -1;
1473
        }
1474
    }
1475

    
1476
    if (!s->mb_intra) {
1477
        int mx, my, cbpy;
1478

    
1479
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1480
        if(cbpy<0){
1481
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1482
            return -1;
1483
        }
1484

    
1485
        cbp|= cbpy<<2;
1486
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1487

    
1488
        h263_pred_motion(s, 0, 0, &mx, &my);
1489
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1490
        my= msmpeg4v2_decode_motion(s, my, 1);
1491

    
1492
        s->mv_dir = MV_DIR_FORWARD;
1493
        s->mv_type = MV_TYPE_16X16;
1494
        s->mv[0][0][0] = mx;
1495
        s->mv[0][0][1] = my;
1496
    } else {
1497
        if(s->msmpeg4_version==2){
1498
            s->ac_pred = get_bits1(&s->gb);
1499
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1500
        } else{
1501
            s->ac_pred = 0;
1502
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1503
            if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1504
        }
1505
    }
1506

    
1507
    s->dsp.clear_blocks(s->block[0]);
1508
    for (i = 0; i < 6; i++) {
1509
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1510
        {
1511
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1512
             return -1;
1513
        }
1514
    }
1515
    return 0;
1516
}
1517

    
1518
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1519
{
1520
    int cbp, code, i;
1521
    uint8_t *coded_val;
1522
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1523

    
1524
    if (s->pict_type == FF_P_TYPE) {
1525
        if (s->use_skip_mb_code) {
1526
            if (get_bits1(&s->gb)) {
1527
                /* skip mb */
1528
                s->mb_intra = 0;
1529
                for(i=0;i<6;i++)
1530
                    s->block_last_index[i] = -1;
1531
                s->mv_dir = MV_DIR_FORWARD;
1532
                s->mv_type = MV_TYPE_16X16;
1533
                s->mv[0][0][0] = 0;
1534
                s->mv[0][0][1] = 0;
1535
                s->mb_skipped = 1;
1536
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1537

    
1538
                return 0;
1539
            }
1540
        }
1541

    
1542
        code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1543
        if (code < 0)
1544
            return -1;
1545
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1546
        s->mb_intra = (~code & 0x40) >> 6;
1547

    
1548
        cbp = code & 0x3f;
1549
    } else {
1550
        s->mb_intra = 1;
1551
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1552
        if (code < 0)
1553
            return -1;
1554
        /* predict coded block pattern */
1555
        cbp = 0;
1556
        for(i=0;i<6;i++) {
1557
            int val = ((code >> (5 - i)) & 1);
1558
            if (i < 4) {
1559
                int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1560
                val = val ^ pred;
1561
                *coded_val = val;
1562
            }
1563
            cbp |= val << (5 - i);
1564
        }
1565
    }
1566

    
1567
    if (!s->mb_intra) {
1568
        int mx, my;
1569
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1570
        if(s->per_mb_rl_table && cbp){
1571
            s->rl_table_index = decode012(&s->gb);
1572
            s->rl_chroma_table_index = s->rl_table_index;
1573
        }
1574
        h263_pred_motion(s, 0, 0, &mx, &my);
1575
        if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1576
            return -1;
1577
        s->mv_dir = MV_DIR_FORWARD;
1578
        s->mv_type = MV_TYPE_16X16;
1579
        s->mv[0][0][0] = mx;
1580
        s->mv[0][0][1] = my;
1581
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1582
    } else {
1583
//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
1584
        s->ac_pred = get_bits1(&s->gb);
1585
        *mb_type_ptr = MB_TYPE_INTRA;
1586
        if(s->inter_intra_pred){
1587
            s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1588
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1589
        }
1590
        if(s->per_mb_rl_table && cbp){
1591
            s->rl_table_index = decode012(&s->gb);
1592
            s->rl_chroma_table_index = s->rl_table_index;
1593
        }
1594
    }
1595

    
1596
    s->dsp.clear_blocks(s->block[0]);
1597
    for (i = 0; i < 6; i++) {
1598
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1599
        {
1600
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1601
            return -1;
1602
        }
1603
    }
1604

    
1605
    return 0;
1606
}
1607
//#define ERROR_DETAILS
1608
int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1609
                              int n, int coded, const uint8_t *scan_table)
1610
{
1611
    int level, i, last, run, run_diff;
1612
    int dc_pred_dir;
1613
    RLTable *rl;
1614
    RL_VLC_ELEM *rl_vlc;
1615
    int qmul, qadd;
1616

    
1617
    if (s->mb_intra) {
1618
        qmul=1;
1619
        qadd=0;
1620

    
1621
        /* DC coef */
1622
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1623

    
1624
        if (level < 0){
1625
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1626
            if(s->inter_intra_pred) level=0;
1627
            else                    return -1;
1628
        }
1629
        if (n < 4) {
1630
            rl = &rl_table[s->rl_table_index];
1631
            if(level > 256*s->y_dc_scale){
1632
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1633
                if(!s->inter_intra_pred) return -1;
1634
            }
1635
        } else {
1636
            rl = &rl_table[3 + s->rl_chroma_table_index];
1637
            if(level > 256*s->c_dc_scale){
1638
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1639
                if(!s->inter_intra_pred) return -1;
1640
            }
1641
        }
1642
        block[0] = level;
1643

    
1644
        run_diff = s->msmpeg4_version >= 4;
1645
        i = 0;
1646
        if (!coded) {
1647
            goto not_coded;
1648
        }
1649
        if (s->ac_pred) {
1650
            if (dc_pred_dir == 0)
1651
                scan_table = s->intra_v_scantable.permutated; /* left */
1652
            else
1653
                scan_table = s->intra_h_scantable.permutated; /* top */
1654
        } else {
1655
            scan_table = s->intra_scantable.permutated;
1656
        }
1657
        rl_vlc= rl->rl_vlc[0];
1658
    } else {
1659
        qmul = s->qscale << 1;
1660
        qadd = (s->qscale - 1) | 1;
1661
        i = -1;
1662
        rl = &rl_table[3 + s->rl_table_index];
1663

    
1664
        if(s->msmpeg4_version==2)
1665
            run_diff = 0;
1666
        else
1667
            run_diff = 1;
1668

    
1669
        if (!coded) {
1670
            s->block_last_index[n] = i;
1671
            return 0;
1672
        }
1673
        if(!scan_table)
1674
            scan_table = s->inter_scantable.permutated;
1675
        rl_vlc= rl->rl_vlc[s->qscale];
1676
    }
1677
  {
1678
    OPEN_READER(re, &s->gb);
1679
    for(;;) {
1680
        UPDATE_CACHE(re, &s->gb);
1681
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1682
        if (level==0) {
1683
            int cache;
1684
            cache= GET_CACHE(re, &s->gb);
1685
            /* escape */
1686
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1687
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1688
                    /* third escape */
1689
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1690
                    UPDATE_CACHE(re, &s->gb);
1691
                    if(s->msmpeg4_version<=3){
1692
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1693
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1694
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1695
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
1696
                    }else{
1697
                        int sign;
1698
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1699
                        if(!s->esc3_level_length){
1700
                            int ll;
1701
                            //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1702
                            if(s->qscale<8){
1703
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1704
                                if(ll==0){
1705
                                    if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1706
                                    SKIP_BITS(re, &s->gb, 1);
1707
                                    ll=8;
1708
                                }
1709
                            }else{
1710
                                ll=2;
1711
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1712
                                    ll++;
1713
                                    SKIP_BITS(re, &s->gb, 1);
1714
                                }
1715
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
1716
                            }
1717

    
1718
                            s->esc3_level_length= ll;
1719
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1720
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1721
                            UPDATE_CACHE(re, &s->gb);
1722
                        }
1723
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1724
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
1725

    
1726
                        sign=  SHOW_UBITS(re, &s->gb, 1);
1727
                        SKIP_BITS(re, &s->gb, 1);
1728

    
1729
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1730
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
1731
                        if(sign) level= -level;
1732
                    }
1733
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1734
#if 0 // waste of time / this will detect very few errors
1735
                    {
1736
                        const int abs_level= FFABS(level);
1737
                        const int run1= run - rl->max_run[last][abs_level] - run_diff;
1738
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1739
                            if(abs_level <= rl->max_level[last][run]){
1740
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1741
                                return DECODING_AC_LOST;
1742
                            }
1743
                            if(abs_level <= rl->max_level[last][run]*2){
1744
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1745
                                return DECODING_AC_LOST;
1746
                            }
1747
                            if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1748
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1749
                                return DECODING_AC_LOST;
1750
                            }
1751
                        }
1752
                    }
1753
#endif
1754
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1755
                    if (level>0) level= level * qmul + qadd;
1756
                    else         level= level * qmul - qadd;
1757
#if 0 // waste of time too :(
1758
                    if(level>2048 || level<-2048){
1759
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1760
                        return DECODING_AC_LOST;
1761
                    }
1762
#endif
1763
                    i+= run + 1;
1764
                    if(last) i+=192;
1765
#ifdef ERROR_DETAILS
1766
                if(run==66)
1767
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1768
                else if((i>62 && i<192) || i>192+63)
1769
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1770
#endif
1771
                } else {
1772
                    /* second escape */
1773
#if MIN_CACHE_BITS < 23
1774
                    LAST_SKIP_BITS(re, &s->gb, 2);
1775
                    UPDATE_CACHE(re, &s->gb);
1776
#else
1777
                    SKIP_BITS(re, &s->gb, 2);
1778
#endif
1779
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1780
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1781
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1782
                    LAST_SKIP_BITS(re, &s->gb, 1);
1783
#ifdef ERROR_DETAILS
1784
                if(run==66)
1785
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1786
                else if((i>62 && i<192) || i>192+63)
1787
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1788
#endif
1789
                }
1790
            } else {
1791
                /* first escape */
1792
#if MIN_CACHE_BITS < 22
1793
                LAST_SKIP_BITS(re, &s->gb, 1);
1794
                UPDATE_CACHE(re, &s->gb);
1795
#else
1796
                SKIP_BITS(re, &s->gb, 1);
1797
#endif
1798
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1799
                i+= run;
1800
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1801
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1802
                LAST_SKIP_BITS(re, &s->gb, 1);
1803
#ifdef ERROR_DETAILS
1804
                if(run==66)
1805
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1806
                else if((i>62 && i<192) || i>192+63)
1807
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1808
#endif
1809
            }
1810
        } else {
1811
            i+= run;
1812
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1813
            LAST_SKIP_BITS(re, &s->gb, 1);
1814
#ifdef ERROR_DETAILS
1815
                if(run==66)
1816
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1817
                else if((i>62 && i<192) || i>192+63)
1818
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1819
#endif
1820
        }
1821
        if (i > 62){
1822
            i-= 192;
1823
            if(i&(~63)){
1824
                const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1825
                if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1826
                    av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1827
                    break;
1828
                }else{
1829
                    av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1830
                    return -1;
1831
                }
1832
            }
1833

    
1834
            block[scan_table[i]] = level;
1835
            break;
1836
        }
1837

    
1838
        block[scan_table[i]] = level;
1839
    }
1840
    CLOSE_READER(re, &s->gb);
1841
  }
1842
 not_coded:
1843
    if (s->mb_intra) {
1844
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1845
        if (s->ac_pred) {
1846
            i = 63; /* XXX: not optimal */
1847
        }
1848
    }
1849
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1850
    s->block_last_index[n] = i;
1851

    
1852
    return 0;
1853
}
1854

    
1855
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1856
{
1857
    int level, pred;
1858

    
1859
    if(s->msmpeg4_version<=2){
1860
        if (n < 4) {
1861
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1862
        } else {
1863
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1864
        }
1865
        if (level < 0)
1866
            return -1;
1867
        level-=256;
1868
    }else{  //FIXME optimize use unified tables & index
1869
        if (n < 4) {
1870
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1871
        } else {
1872
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1873
        }
1874
        if (level < 0){
1875
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1876
            return -1;
1877
        }
1878

    
1879
        if (level == DC_MAX) {
1880
            level = get_bits(&s->gb, 8);
1881
            if (get_bits1(&s->gb))
1882
                level = -level;
1883
        } else if (level != 0) {
1884
            if (get_bits1(&s->gb))
1885
                level = -level;
1886
        }
1887
    }
1888

    
1889
    if(s->msmpeg4_version==1){
1890
        int32_t *dc_val;
1891
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1892
        level += pred;
1893

    
1894
        /* update predictor */
1895
        *dc_val= level;
1896
    }else{
1897
        int16_t *dc_val;
1898
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1899
        level += pred;
1900

    
1901
        /* update predictor */
1902
        if (n < 4) {
1903
            *dc_val = level * s->y_dc_scale;
1904
        } else {
1905
            *dc_val = level * s->c_dc_scale;
1906
        }
1907
    }
1908

    
1909
    return level;
1910
}
1911

    
1912
int ff_msmpeg4_decode_motion(MpegEncContext * s,
1913
                                 int *mx_ptr, int *my_ptr)
1914
{
1915
    MVTable *mv;
1916
    int code, mx, my;
1917

    
1918
    mv = &mv_tables[s->mv_table_index];
1919

    
1920
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1921
    if (code < 0){
1922
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1923
        return -1;
1924
    }
1925
    if (code == mv->n) {
1926
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1927
        mx = get_bits(&s->gb, 6);
1928
        my = get_bits(&s->gb, 6);
1929
    } else {
1930
        mx = mv->table_mvx[code];
1931
        my = mv->table_mvy[code];
1932
    }
1933

    
1934
    mx += *mx_ptr - 32;
1935
    my += *my_ptr - 32;
1936
    /* WARNING : they do not do exactly modulo encoding */
1937
    if (mx <= -64)
1938
        mx += 64;
1939
    else if (mx >= 64)
1940
        mx -= 64;
1941

    
1942
    if (my <= -64)
1943
        my += 64;
1944
    else if (my >= 64)
1945
        my -= 64;
1946
    *mx_ptr = mx;
1947
    *my_ptr = my;
1948
    return 0;
1949
}