Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 9488b966

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

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

    
43
#define DC_VLC_BITS 9
44
#define CBPY_VLC_BITS 6
45
#define INTER_INTRA_VLC_BITS 3
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
#define MB_NON_INTRA_VLC_BITS 9
54
#define MB_INTRA_VLC_BITS 9
55

    
56
#define II_BITRATE 128*1024
57
#define MBAC_BITRATE 50*1024
58

    
59
#define DEFAULT_INTER_INDEX 3
60

    
61
static uint32_t v2_dc_lum_table[512][2];
62
static uint32_t v2_dc_chroma_table[512][2];
63

    
64
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
65
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
66
                                       int n, int coded, const uint8_t *scantable);
67
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
68
static int msmpeg4_decode_motion(MpegEncContext * s,
69
                                 int *mx_ptr, int *my_ptr);
70
static void init_h263_dc_for_msmpeg4(void);
71
static inline void msmpeg4_memsetw(short *tab, int val, int n);
72
#ifdef CONFIG_ENCODERS
73
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
74
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
75
#endif //CONFIG_ENCODERS
76
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
77
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
78
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
79

    
80
/* vc1 externs */
81
extern uint8_t wmv3_dc_scale_table[32];
82

    
83
#ifdef DEBUG
84
int intra_count = 0;
85
int frame_count = 0;
86
#endif
87

    
88
#include "msmpeg4data.h"
89

    
90
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if it is not references
91
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
92
#endif //CONFIG_ENCODERS
93

    
94
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
95

    
96
static void common_init(MpegEncContext * s)
97
{
98
    static int inited=0;
99

    
100
    switch(s->msmpeg4_version){
101
    case 1:
102
    case 2:
103
        s->y_dc_scale_table=
104
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
105
        break;
106
    case 3:
107
        if(s->workaround_bugs){
108
            s->y_dc_scale_table= old_ff_y_dc_scale_table;
109
            s->c_dc_scale_table= old_ff_c_dc_scale_table;
110
        } else{
111
            s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
112
            s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
113
        }
114
        break;
115
    case 4:
116
    case 5:
117
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
118
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
119
        break;
120
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
121
    case 6:
122
        s->y_dc_scale_table= wmv3_dc_scale_table;
123
        s->c_dc_scale_table= wmv3_dc_scale_table;
124
        break;
125
#endif
126

    
127
    }
128

    
129

    
130
    if(s->msmpeg4_version>=4){
131
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
132
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
133
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
134
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
135
    }
136
    //Note the default tables are set in common_init in mpegvideo.c
137

    
138
    if(!inited){
139
        inited=1;
140

    
141
        init_h263_dc_for_msmpeg4();
142
    }
143
}
144

    
145
#ifdef CONFIG_ENCODERS
146

    
147
/* build the table which associate a (x,y) motion vector to a vlc */
148
static void init_mv_table(MVTable *tab)
149
{
150
    int i, x, y;
151

    
152
    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
153
    /* mark all entries as not used */
154
    for(i=0;i<4096;i++)
155
        tab->table_mv_index[i] = tab->n;
156

    
157
    for(i=0;i<tab->n;i++) {
158
        x = tab->table_mvx[i];
159
        y = tab->table_mvy[i];
160
        tab->table_mv_index[(x << 6) | y] = i;
161
    }
162
}
163

    
164
void ff_code012(PutBitContext *pb, int n)
165
{
166
    if (n == 0) {
167
        put_bits(pb, 1, 0);
168
    } else {
169
        put_bits(pb, 1, 1);
170
        put_bits(pb, 1, (n >= 2));
171
    }
172
}
173

    
174
void ff_msmpeg4_encode_init(MpegEncContext *s)
175
{
176
    static int init_done=0;
177
    int i;
178

    
179
    common_init(s);
180
    if(s->msmpeg4_version>=4){
181
        s->min_qcoeff= -255;
182
        s->max_qcoeff=  255;
183
    }
184

    
185
    if (!init_done) {
186
        /* init various encoding tables */
187
        init_done = 1;
188
        init_mv_table(&mv_tables[0]);
189
        init_mv_table(&mv_tables[1]);
190
        for(i=0;i<NB_RL_TABLES;i++)
191
            init_rl(&rl_table[i], static_rl_table_store[i]);
192

    
193
        for(i=0; i<NB_RL_TABLES; i++){
194
            int level;
195
            for(level=0; level<=MAX_LEVEL; level++){
196
                int run;
197
                for(run=0; run<=MAX_RUN; run++){
198
                    int last;
199
                    for(last=0; last<2; last++){
200
                        rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
201
                    }
202
                }
203
            }
204
        }
205
    }
206
}
207

    
208
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
209
    int size=0;
210
    int code;
211
    int run_diff= intra ? 0 : 1;
212

    
213
    code = get_rl_index(rl, last, run, level);
214
    size+= rl->table_vlc[code][1];
215
    if (code == rl->n) {
216
        int level1, run1;
217

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

    
249
void ff_find_best_tables(MpegEncContext * s)
250
{
251
    int i;
252
    int best       =-1, best_size       =9999999;
253
    int chroma_best=-1, best_chroma_size=9999999;
254

    
255
    for(i=0; i<3; i++){
256
        int level;
257
        int chroma_size=0;
258
        int size=0;
259

    
260
        if(i>0){// ;)
261
            size++;
262
            chroma_size++;
263
        }
264
        for(level=0; level<=MAX_LEVEL; level++){
265
            int run;
266
            for(run=0; run<=MAX_RUN; run++){
267
                int last;
268
                const int last_size= size + chroma_size;
269
                for(last=0; last<2; last++){
270
                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
271
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
272
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
273

    
274
                    if(s->pict_type==I_TYPE){
275
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
276
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
277
                    }else{
278
                        size+=        intra_luma_count  *rl_length[i  ][level][run][last]
279
                                     +intra_chroma_count*rl_length[i+3][level][run][last]
280
                                     +inter_count       *rl_length[i+3][level][run][last];
281
                    }
282
                }
283
                if(last_size == size+chroma_size) break;
284
            }
285
        }
286
        if(size<best_size){
287
            best_size= size;
288
            best= i;
289
        }
290
        if(chroma_size<best_chroma_size){
291
            best_chroma_size= chroma_size;
292
            chroma_best= i;
293
        }
294
    }
295

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

    
299
    if(s->pict_type==P_TYPE) chroma_best= best;
300

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

    
303
    s->rl_table_index       =        best;
304
    s->rl_chroma_table_index= chroma_best;
305

    
306
    if(s->pict_type != s->last_non_b_pict_type){
307
        s->rl_table_index= 2;
308
        if(s->pict_type==I_TYPE)
309
            s->rl_chroma_table_index= 1;
310
        else
311
            s->rl_chroma_table_index= 2;
312
    }
313

    
314
}
315

    
316
/* write MSMPEG4 compatible frame header */
317
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
318
{
319
    ff_find_best_tables(s);
320

    
321
    align_put_bits(&s->pb);
322
    put_bits(&s->pb, 2, s->pict_type - 1);
323

    
324
    put_bits(&s->pb, 5, s->qscale);
325
    if(s->msmpeg4_version<=2){
326
        s->rl_table_index = 2;
327
        s->rl_chroma_table_index = 2;
328
    }
329

    
330
    s->dc_table_index = 1;
331
    s->mv_table_index = 1; /* only if P frame */
332
    s->use_skip_mb_code = 1; /* only if P frame */
333
    s->per_mb_rl_table = 0;
334
    if(s->msmpeg4_version==4)
335
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
336
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
337

    
338
    if (s->pict_type == I_TYPE) {
339
        s->slice_height= s->mb_height/1;
340
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
341

    
342
        if(s->msmpeg4_version==4){
343
            msmpeg4_encode_ext_header(s);
344
            if(s->bit_rate>MBAC_BITRATE)
345
                put_bits(&s->pb, 1, s->per_mb_rl_table);
346
        }
347

    
348
        if(s->msmpeg4_version>2){
349
            if(!s->per_mb_rl_table){
350
                ff_code012(&s->pb, s->rl_chroma_table_index);
351
                ff_code012(&s->pb, s->rl_table_index);
352
            }
353

    
354
            put_bits(&s->pb, 1, s->dc_table_index);
355
        }
356
    } else {
357
        put_bits(&s->pb, 1, s->use_skip_mb_code);
358

    
359
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
360
            put_bits(&s->pb, 1, s->per_mb_rl_table);
361

    
362
        if(s->msmpeg4_version>2){
363
            if(!s->per_mb_rl_table)
364
                ff_code012(&s->pb, s->rl_table_index);
365

    
366
            put_bits(&s->pb, 1, s->dc_table_index);
367

    
368
            put_bits(&s->pb, 1, s->mv_table_index);
369
        }
370
    }
371

    
372
    s->esc3_level_length= 0;
373
    s->esc3_run_length= 0;
374

    
375
#ifdef DEBUG
376
    intra_count = 0;
377
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
378
#endif
379
}
380

    
381
void msmpeg4_encode_ext_header(MpegEncContext * s)
382
{
383
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
384

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

    
387
        if(s->msmpeg4_version>=3)
388
            put_bits(&s->pb, 1, s->flipflop_rounding);
389
        else
390
            assert(s->flipflop_rounding==0);
391
}
392

    
393
#endif //CONFIG_ENCODERS
394

    
395
/* predict coded block */
396
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
397
{
398
    int xy, wrap, pred, a, b, c;
399

    
400
    xy = s->block_index[n];
401
    wrap = s->b8_stride;
402

    
403
    /* B C
404
     * A X
405
     */
406
    a = s->coded_block[xy - 1       ];
407
    b = s->coded_block[xy - 1 - wrap];
408
    c = s->coded_block[xy     - wrap];
409

    
410
    if (b == c) {
411
        pred = a;
412
    } else {
413
        pred = c;
414
    }
415

    
416
    /* store value */
417
    *coded_block_ptr = &s->coded_block[xy];
418

    
419
    return pred;
420
}
421

    
422
#ifdef CONFIG_ENCODERS
423

    
424
static void msmpeg4_encode_motion(MpegEncContext * s,
425
                                  int mx, int my)
426
{
427
    int code;
428
    MVTable *mv;
429

    
430
    /* modulo encoding */
431
    /* WARNING : you cannot reach all the MVs even with the modulo
432
       encoding. This is a somewhat strange compromise they took !!!  */
433
    if (mx <= -64)
434
        mx += 64;
435
    else if (mx >= 64)
436
        mx -= 64;
437
    if (my <= -64)
438
        my += 64;
439
    else if (my >= 64)
440
        my -= 64;
441

    
442
    mx += 32;
443
    my += 32;
444
#if 0
445
    if ((unsigned)mx >= 64 ||
446
        (unsigned)my >= 64)
447
        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
448
#endif
449
    mv = &mv_tables[s->mv_table_index];
450

    
451
    code = mv->table_mv_index[(mx << 6) | my];
452
    put_bits(&s->pb,
453
             mv->table_mv_bits[code],
454
             mv->table_mv_code[code]);
455
    if (code == mv->n) {
456
        /* escape : code literally */
457
        put_bits(&s->pb, 6, mx);
458
        put_bits(&s->pb, 6, my);
459
    }
460
}
461

    
462
static inline void handle_slices(MpegEncContext *s){
463
    if (s->mb_x == 0) {
464
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
465
            if(s->msmpeg4_version < 4){
466
                ff_mpeg4_clean_buffers(s);
467
            }
468
            s->first_slice_line = 1;
469
        } else {
470
            s->first_slice_line = 0;
471
        }
472
    }
473
}
474

    
475
void msmpeg4_encode_mb(MpegEncContext * s,
476
                       DCTELEM block[6][64],
477
                       int motion_x, int motion_y)
478
{
479
    int cbp, coded_cbp, i;
480
    int pred_x, pred_y;
481
    uint8_t *coded_block;
482

    
483
    handle_slices(s);
484

    
485
    if (!s->mb_intra) {
486
        /* compute cbp */
487
        cbp = 0;
488
        for (i = 0; i < 6; i++) {
489
            if (s->block_last_index[i] >= 0)
490
                cbp |= 1 << (5 - i);
491
        }
492
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
493
            /* skip macroblock */
494
            put_bits(&s->pb, 1, 1);
495
            s->last_bits++;
496
            s->misc_bits++;
497
            s->skip_count++;
498

    
499
            return;
500
        }
501
        if (s->use_skip_mb_code)
502
            put_bits(&s->pb, 1, 0);     /* mb coded */
503

    
504
        if(s->msmpeg4_version<=2){
505
            put_bits(&s->pb,
506
                     v2_mb_type[cbp&3][1],
507
                     v2_mb_type[cbp&3][0]);
508
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
509
            else             coded_cbp= cbp;
510

    
511
            put_bits(&s->pb,
512
                     cbpy_tab[coded_cbp>>2][1],
513
                     cbpy_tab[coded_cbp>>2][0]);
514

    
515
            s->misc_bits += get_bits_diff(s);
516

    
517
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
518
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
519
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
520
        }else{
521
            put_bits(&s->pb,
522
                     table_mb_non_intra[cbp + 64][1],
523
                     table_mb_non_intra[cbp + 64][0]);
524

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

    
527
            /* motion vector */
528
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
529
            msmpeg4_encode_motion(s, motion_x - pred_x,
530
                                  motion_y - pred_y);
531
        }
532

    
533
        s->mv_bits += get_bits_diff(s);
534

    
535
        for (i = 0; i < 6; i++) {
536
            ff_msmpeg4_encode_block(s, block[i], i);
537
        }
538
        s->p_tex_bits += get_bits_diff(s);
539
    } else {
540
        /* compute cbp */
541
        cbp = 0;
542
        coded_cbp = 0;
543
        for (i = 0; i < 6; i++) {
544
            int val, pred;
545
            val = (s->block_last_index[i] >= 1);
546
            cbp |= val << (5 - i);
547
            if (i < 4) {
548
                /* predict value for close blocks only for luma */
549
                pred = coded_block_pred(s, i, &coded_block);
550
                *coded_block = val;
551
                val = val ^ pred;
552
            }
553
            coded_cbp |= val << (5 - i);
554
        }
555
#if 0
556
        if (coded_cbp)
557
            printf("cbp=%x %x\n", cbp, coded_cbp);
558
#endif
559

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

    
594
        for (i = 0; i < 6; i++) {
595
            ff_msmpeg4_encode_block(s, block[i], i);
596
        }
597
        s->i_tex_bits += get_bits_diff(s);
598
        s->i_count++;
599
    }
600
}
601

    
602
#endif //CONFIG_ENCODERS
603

    
604
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
605
                                    int32_t **dc_val_ptr)
606
{
607
    int i;
608

    
609
    if (n < 4) {
610
        i= 0;
611
    } else {
612
        i= n-3;
613
    }
614

    
615
    *dc_val_ptr= &s->last_dc[i];
616
    return s->last_dc[i];
617
}
618

    
619
static int get_dc(uint8_t *src, int stride, int scale)
620
{
621
    int y;
622
    int sum=0;
623
    for(y=0; y<8; y++){
624
        int x;
625
        for(x=0; x<8; x++){
626
            sum+=src[x + y*stride];
627
        }
628
    }
629
    return FASTDIV((sum + (scale>>1)), scale);
630
}
631

    
632
/* dir = 0: left, dir = 1: top prediction */
633
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
634
                             int16_t **dc_val_ptr, int *dir_ptr)
635
{
636
    int a, b, c, wrap, pred, scale;
637
    int16_t *dc_val;
638

    
639
    /* find prediction */
640
    if (n < 4) {
641
        scale = s->y_dc_scale;
642
    } else {
643
        scale = s->c_dc_scale;
644
    }
645

    
646
    wrap = s->block_wrap[n];
647
    dc_val= s->dc_val[0] + s->block_index[n];
648

    
649
    /* B C
650
     * A X
651
     */
652
    a = dc_val[ - 1];
653
    b = dc_val[ - 1 - wrap];
654
    c = dc_val[ - wrap];
655

    
656
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
657
        b=c=1024;
658
    }
659

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

    
705
            if(n==1){
706
                pred=a;
707
                *dir_ptr = 0;
708
            }else if(n==2){
709
                pred=c;
710
                *dir_ptr = 1;
711
            }else if(n==3){
712
                if (abs(a - b) < abs(b - c)) {
713
                    pred = c;
714
                    *dir_ptr = 1;
715
                } else {
716
                    pred = a;
717
                    *dir_ptr = 0;
718
                }
719
            }else{
720
                if(n<4){
721
                    wrap= s->linesize;
722
                    dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
723
                }else{
724
                    wrap= s->uvlinesize;
725
                    dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
726
                }
727
                if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
728
                else           a= get_dc(dest-8, wrap, scale*8);
729
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
730
                else           c= get_dc(dest-8*wrap, wrap, scale*8);
731

    
732
                if (s->h263_aic_dir==0) {
733
                    pred= a;
734
                    *dir_ptr = 0;
735
                }else if (s->h263_aic_dir==1) {
736
                    if(n==0){
737
                        pred= c;
738
                        *dir_ptr = 1;
739
                    }else{
740
                        pred= a;
741
                        *dir_ptr = 0;
742
                    }
743
                }else if (s->h263_aic_dir==2) {
744
                    if(n==0){
745
                        pred= a;
746
                        *dir_ptr = 0;
747
                    }else{
748
                        pred= c;
749
                        *dir_ptr = 1;
750
                    }
751
                } else {
752
                    pred= c;
753
                    *dir_ptr = 1;
754
                }
755
            }
756
        }else{
757
            if (abs(a - b) < abs(b - c)) {
758
                pred = c;
759
                *dir_ptr = 1;
760
            } else {
761
                pred = a;
762
                *dir_ptr = 0;
763
            }
764
        }
765
    }else{
766
        if (abs(a - b) <= abs(b - c)) {
767
            pred = c;
768
            *dir_ptr = 1;
769
        } else {
770
            pred = a;
771
            *dir_ptr = 0;
772
        }
773
    }
774

    
775
    /* update predictor */
776
    *dc_val_ptr = &dc_val[0];
777
    return pred;
778
}
779

    
780
#define DC_MAX 119
781

    
782
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
783
{
784
    int sign, code;
785
    int pred, extquant;
786
    int extrabits = 0;
787

    
788
    if(s->msmpeg4_version==1){
789
        int32_t *dc_val;
790
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
791

    
792
        /* update predictor */
793
        *dc_val= level;
794
    }else{
795
        int16_t *dc_val;
796
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
797

    
798
        /* update predictor */
799
        if (n < 4) {
800
            *dc_val = level * s->y_dc_scale;
801
        } else {
802
            *dc_val = level * s->c_dc_scale;
803
        }
804
    }
805

    
806
    /* do the prediction */
807
    level -= pred;
808

    
809
    if(s->msmpeg4_version<=2){
810
        if (n < 4) {
811
            put_bits(&s->pb,
812
                     v2_dc_lum_table[level+256][1],
813
                     v2_dc_lum_table[level+256][0]);
814
        }else{
815
            put_bits(&s->pb,
816
                     v2_dc_chroma_table[level+256][1],
817
                     v2_dc_chroma_table[level+256][0]);
818
        }
819
    }else{
820
        sign = 0;
821
        if (level < 0) {
822
            level = -level;
823
            sign = 1;
824
        }
825
        code = level;
826
        if (code > DC_MAX)
827
            code = DC_MAX;
828
        else if( s->msmpeg4_version>=6 ) {
829
            if( s->qscale == 1 ) {
830
                extquant = (level + 3) & 0x3;
831
                code  = ((level+3)>>2);
832
            } else if( s->qscale == 2 ) {
833
                extquant = (level + 1) & 0x1;
834
                code  = ((level+1)>>1);
835
            }
836
        }
837

    
838
        if (s->dc_table_index == 0) {
839
            if (n < 4) {
840
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
841
            } else {
842
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
843
            }
844
        } else {
845
            if (n < 4) {
846
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
847
            } else {
848
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
849
            }
850
        }
851

    
852
        if(s->msmpeg4_version>=6 && s->qscale<=2)
853
            extrabits = 3 - s->qscale;
854

    
855
        if (code == DC_MAX)
856
            put_bits(&s->pb, 8 + extrabits, level);
857
        else if(extrabits > 0)//== VC1 && s->qscale<=2
858
            put_bits(&s->pb, extrabits, extquant);
859

    
860
        if (level != 0) {
861
            put_bits(&s->pb, 1, sign);
862
        }
863
    }
864
}
865

    
866
/* Encoding of a block. Very similar to MPEG4 except for a different
867
   escape coding (same as H263) and more vlc tables.
868
 */
869
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
870
{
871
    int level, run, last, i, j, last_index;
872
    int last_non_zero, sign, slevel;
873
    int code, run_diff, dc_pred_dir;
874
    const RLTable *rl;
875
    const uint8_t *scantable;
876

    
877
    if (s->mb_intra) {
878
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
879
        i = 1;
880
        if (n < 4) {
881
            rl = &rl_table[s->rl_table_index];
882
        } else {
883
            rl = &rl_table[3 + s->rl_chroma_table_index];
884
        }
885
        run_diff = s->msmpeg4_version>=4;
886
        scantable= s->intra_scantable.permutated;
887
    } else {
888
        i = 0;
889
        rl = &rl_table[3 + s->rl_table_index];
890
        if(s->msmpeg4_version<=2)
891
            run_diff = 0;
892
        else
893
            run_diff = 1;
894
        scantable= s->inter_scantable.permutated;
895
    }
896

    
897
    /* recalculate block_last_index for M$ wmv1 */
898
    if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
899
        for(last_index=63; last_index>=0; last_index--){
900
            if(block[scantable[last_index]]) break;
901
        }
902
        s->block_last_index[n]= last_index;
903
    }else
904
        last_index = s->block_last_index[n];
905
    /* AC coefs */
906
    last_non_zero = i - 1;
907
    for (; i <= last_index; i++) {
908
        j = scantable[i];
909
        level = block[j];
910
        if (level) {
911
            run = i - last_non_zero - 1;
912
            last = (i == last_index);
913
            sign = 0;
914
            slevel = level;
915
            if (level < 0) {
916
                sign = 1;
917
                level = -level;
918
            }
919

    
920
            if(level<=MAX_LEVEL && run<=MAX_RUN){
921
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
922
            }
923
#if 0
924
else
925
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
926
#endif
927
            code = get_rl_index(rl, last, run, level);
928
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
929
            if (code == rl->n) {
930
                int level1, run1;
931

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

    
990
/****************************************/
991
/* decoding stuff */
992

    
993
static VLC mb_non_intra_vlc[4];
994
static VLC v2_dc_lum_vlc;
995
static VLC v2_dc_chroma_vlc;
996
static VLC cbpy_vlc;
997
static VLC v2_intra_cbpc_vlc;
998
static VLC v2_mb_type_vlc;
999
static VLC v2_mv_vlc;
1000
static VLC v1_intra_cbpc_vlc;
1001
static VLC v1_inter_cbpc_vlc;
1002
static VLC inter_intra_vlc;
1003

    
1004
/* This table is practically identical to the one from h263
1005
 * except that it is inverted. */
1006
static void init_h263_dc_for_msmpeg4(void)
1007
{
1008
        int level, uni_code, uni_len;
1009

    
1010
        for(level=-256; level<256; level++){
1011
            int size, v, l;
1012
            /* find number of bits */
1013
            size = 0;
1014
            v = abs(level);
1015
            while (v) {
1016
                v >>= 1;
1017
                    size++;
1018
            }
1019

    
1020
            if (level < 0)
1021
                l= (-level) ^ ((1 << size) - 1);
1022
            else
1023
                l= level;
1024

    
1025
            /* luminance h263 */
1026
            uni_code= DCtab_lum[size][0];
1027
            uni_len = DCtab_lum[size][1];
1028
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1029

    
1030
            if (size > 0) {
1031
                uni_code<<=size; uni_code|=l;
1032
                uni_len+=size;
1033
                if (size > 8){
1034
                    uni_code<<=1; uni_code|=1;
1035
                    uni_len++;
1036
                }
1037
            }
1038
            v2_dc_lum_table[level+256][0]= uni_code;
1039
            v2_dc_lum_table[level+256][1]= uni_len;
1040

    
1041
            /* chrominance h263 */
1042
            uni_code= DCtab_chrom[size][0];
1043
            uni_len = DCtab_chrom[size][1];
1044
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1045

    
1046
            if (size > 0) {
1047
                uni_code<<=size; uni_code|=l;
1048
                uni_len+=size;
1049
                if (size > 8){
1050
                    uni_code<<=1; uni_code|=1;
1051
                    uni_len++;
1052
                }
1053
            }
1054
            v2_dc_chroma_table[level+256][0]= uni_code;
1055
            v2_dc_chroma_table[level+256][1]= uni_len;
1056

    
1057
        }
1058
}
1059

    
1060
/* init all vlc decoding tables */
1061
int ff_msmpeg4_decode_init(MpegEncContext *s)
1062
{
1063
    static int done = 0;
1064
    int i;
1065
    MVTable *mv;
1066

    
1067
    common_init(s);
1068

    
1069
    if (!done) {
1070
        done = 1;
1071

    
1072
        for(i=0;i<NB_RL_TABLES;i++) {
1073
            init_rl(&rl_table[i], static_rl_table_store[i]);
1074
            init_vlc_rl(&rl_table[i], 1);
1075
        }
1076
        for(i=0;i<2;i++) {
1077
            mv = &mv_tables[i];
1078
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1079
                     mv->table_mv_bits, 1, 1,
1080
                     mv->table_mv_code, 2, 2, 1);
1081
        }
1082

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

    
1096
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1097
                 &v2_dc_lum_table[0][1], 8, 4,
1098
                 &v2_dc_lum_table[0][0], 8, 4, 1);
1099
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1100
                 &v2_dc_chroma_table[0][1], 8, 4,
1101
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
1102

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

    
1116
        for(i=0; i<4; i++){
1117
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1118
                     &wmv2_inter_table[i][0][1], 8, 4,
1119
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1120
        }
1121

    
1122
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1123
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
1124
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1125

    
1126
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1127
                 intra_MCBPC_bits, 1, 1,
1128
                 intra_MCBPC_code, 1, 1, 1);
1129
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1130
                 inter_MCBPC_bits, 1, 1,
1131
                 inter_MCBPC_code, 1, 1, 1);
1132

    
1133
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1134
                 &table_inter_intra[0][1], 2, 1,
1135
                 &table_inter_intra[0][0], 2, 1, 1);
1136
    }
1137

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

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

    
1156
    return 0;
1157
}
1158

    
1159
int msmpeg4_decode_picture_header(MpegEncContext * s)
1160
{
1161
    int code;
1162

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

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

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

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

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

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

    
1220
            s->slice_height = s->mb_height / (code - 0x16);
1221
        }
1222

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

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

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

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

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

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

    
1279
            s->dc_table_index = get_bits1(&s->gb);
1280

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

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

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

    
1294
            s->dc_table_index = get_bits1(&s->gb);
1295

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

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

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

    
1319
    s->esc3_level_length= 0;
1320
    s->esc3_run_length= 0;
1321

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

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

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

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

    
1357
    return 0;
1358
}
1359

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

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

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

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

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

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

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

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

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

    
1431
    return val;
1432
}
1433

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

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

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

    
1463
        s->mb_intra = code >>2;
1464

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

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

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

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

    
1490
        h263_pred_motion(s, 0, 0, &mx, &my);
1491
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1492
        my= msmpeg4v2_decode_motion(s, my, 1);
1493

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

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

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

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

    
1540
                return 0;
1541
            }
1542
        }
1543

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

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

    
1569
    if (!s->mb_intra) {
1570
        int mx, my;
1571
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1572
        if(s->per_mb_rl_table && cbp){
1573
            s->rl_table_index = decode012(&s->gb);
1574
            s->rl_chroma_table_index = s->rl_table_index;
1575
        }
1576
        h263_pred_motion(s, 0, 0, &mx, &my);
1577
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1578
            return -1;
1579
        s->mv_dir = MV_DIR_FORWARD;
1580
        s->mv_type = MV_TYPE_16X16;
1581
        s->mv[0][0][0] = mx;
1582
        s->mv[0][0][1] = my;
1583
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1584
    } else {
1585
//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));
1586
        s->ac_pred = get_bits1(&s->gb);
1587
        *mb_type_ptr = MB_TYPE_INTRA;
1588
        if(s->inter_intra_pred){
1589
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1590
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1591
        }
1592
        if(s->per_mb_rl_table && cbp){
1593
            s->rl_table_index = decode012(&s->gb);
1594
            s->rl_chroma_table_index = s->rl_table_index;
1595
        }
1596
    }
1597

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

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

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

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

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

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

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

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

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

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

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

    
1836
            block[scan_table[i]] = level;
1837
            break;
1838
        }
1839

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

    
1854
    return 0;
1855
}
1856

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

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

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

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

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

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

    
1911
    return level;
1912
}
1913

    
1914
static int msmpeg4_decode_motion(MpegEncContext * s,
1915
                                 int *mx_ptr, int *my_ptr)
1916
{
1917
    MVTable *mv;
1918
    int code, mx, my;
1919

    
1920
    mv = &mv_tables[s->mv_table_index];
1921

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

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

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

    
1953
/* cleanest way to support it
1954
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1955
 * as allmost everything would be in the common file
1956
 */
1957
#include "wmv2.c"