Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 42ef2dbc

History | View | Annotate | Download (60 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
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 *
22
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
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
static inline void 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
#include "msmpeg4tab.h"
90

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

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

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

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

    
128
    }
129

    
130

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

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

    
142
        init_h263_dc_for_msmpeg4();
143
    }
144
}
145

    
146
#ifdef CONFIG_ENCODERS
147

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
315
}
316

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
394
#endif //CONFIG_ENCODERS
395

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

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

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

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

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

    
420
    return pred;
421
}
422

    
423
#ifdef CONFIG_ENCODERS
424

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

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

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

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

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

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

    
484
    handle_slices(s);
485

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

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

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

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

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

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

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

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

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

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

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

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

    
603
#endif //CONFIG_ENCODERS
604

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

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

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

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

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

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

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

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

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

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

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

    
733
                if (s->h263_aic_dir==0) {
734
                    pred= a;
735
                    *dir_ptr = 0;
736
                }else if (s->h263_aic_dir==1) {
737
                    if(n==0){
738
                        pred= c;
739
                        *dir_ptr = 1;
740
                    }else{
741
                        pred= a;
742
                        *dir_ptr = 0;
743
                    }
744
                }else if (s->h263_aic_dir==2) {
745
                    if(n==0){
746
                        pred= a;
747
                        *dir_ptr = 0;
748
                    }else{
749
                        pred= c;
750
                        *dir_ptr = 1;
751
                    }
752
                } else {
753
                    pred= c;
754
                    *dir_ptr = 1;
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
    }else{
767
        if (abs(a - b) <= abs(b - c)) {
768
            pred = c;
769
            *dir_ptr = 1;
770
        } else {
771
            pred = a;
772
            *dir_ptr = 0;
773
        }
774
    }
775

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

    
781
#define DC_MAX 119
782

    
783
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
784
{
785
    int sign, code;
786
    int pred;
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

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

    
843
        if (code == DC_MAX)
844
            put_bits(&s->pb, 8, level);
845

    
846
        if (level != 0) {
847
            put_bits(&s->pb, 1, sign);
848
        }
849
    }
850
}
851

    
852
/* Encoding of a block. Very similar to MPEG4 except for a different
853
   escape coding (same as H263) and more vlc tables.
854
 */
855
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
856
{
857
    int level, run, last, i, j, last_index;
858
    int last_non_zero, sign, slevel;
859
    int code, run_diff, dc_pred_dir;
860
    const RLTable *rl;
861
    const uint8_t *scantable;
862

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

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

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

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

    
972
/****************************************/
973
/* decoding stuff */
974

    
975
static VLC mb_non_intra_vlc[4];
976
static VLC v2_dc_lum_vlc;
977
static VLC v2_dc_chroma_vlc;
978
static VLC cbpy_vlc;
979
static VLC v2_intra_cbpc_vlc;
980
static VLC v2_mb_type_vlc;
981
static VLC v2_mv_vlc;
982
static VLC v1_intra_cbpc_vlc;
983
static VLC v1_inter_cbpc_vlc;
984
static VLC inter_intra_vlc;
985

    
986
/* this table is practically identical to the one from h263 except that its inverted */
987
static void init_h263_dc_for_msmpeg4(void)
988
{
989
        int level, uni_code, uni_len;
990

    
991
        for(level=-256; level<256; level++){
992
            int size, v, l;
993
            /* find number of bits */
994
            size = 0;
995
            v = abs(level);
996
            while (v) {
997
                v >>= 1;
998
                    size++;
999
            }
1000

    
1001
            if (level < 0)
1002
                l= (-level) ^ ((1 << size) - 1);
1003
            else
1004
                l= level;
1005

    
1006
            /* luminance h263 */
1007
            uni_code= DCtab_lum[size][0];
1008
            uni_len = DCtab_lum[size][1];
1009
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1010

    
1011
            if (size > 0) {
1012
                uni_code<<=size; uni_code|=l;
1013
                uni_len+=size;
1014
                if (size > 8){
1015
                    uni_code<<=1; uni_code|=1;
1016
                    uni_len++;
1017
                }
1018
            }
1019
            v2_dc_lum_table[level+256][0]= uni_code;
1020
            v2_dc_lum_table[level+256][1]= uni_len;
1021

    
1022
            /* chrominance h263 */
1023
            uni_code= DCtab_chrom[size][0];
1024
            uni_len = DCtab_chrom[size][1];
1025
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1026

    
1027
            if (size > 0) {
1028
                uni_code<<=size; uni_code|=l;
1029
                uni_len+=size;
1030
                if (size > 8){
1031
                    uni_code<<=1; uni_code|=1;
1032
                    uni_len++;
1033
                }
1034
            }
1035
            v2_dc_chroma_table[level+256][0]= uni_code;
1036
            v2_dc_chroma_table[level+256][1]= uni_len;
1037

    
1038
        }
1039
}
1040

    
1041
/* init all vlc decoding tables */
1042
int ff_msmpeg4_decode_init(MpegEncContext *s)
1043
{
1044
    static int done = 0;
1045
    int i;
1046
    MVTable *mv;
1047

    
1048
    common_init(s);
1049

    
1050
    if (!done) {
1051
        done = 1;
1052

    
1053
        for(i=0;i<NB_RL_TABLES;i++) {
1054
            init_rl(&rl_table[i], static_rl_table_store[i]);
1055
            init_vlc_rl(&rl_table[i], 1);
1056
        }
1057
        for(i=0;i<2;i++) {
1058
            mv = &mv_tables[i];
1059
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1060
                     mv->table_mv_bits, 1, 1,
1061
                     mv->table_mv_code, 2, 2, 1);
1062
        }
1063

    
1064
        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1065
                 &ff_table0_dc_lum[0][1], 8, 4,
1066
                 &ff_table0_dc_lum[0][0], 8, 4, 1);
1067
        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1068
                 &ff_table0_dc_chroma[0][1], 8, 4,
1069
                 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1070
        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1071
                 &ff_table1_dc_lum[0][1], 8, 4,
1072
                 &ff_table1_dc_lum[0][0], 8, 4, 1);
1073
        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1074
                 &ff_table1_dc_chroma[0][1], 8, 4,
1075
                 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1076

    
1077
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1078
                 &v2_dc_lum_table[0][1], 8, 4,
1079
                 &v2_dc_lum_table[0][0], 8, 4, 1);
1080
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1081
                 &v2_dc_chroma_table[0][1], 8, 4,
1082
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
1083

    
1084
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1085
                 &cbpy_tab[0][1], 2, 1,
1086
                 &cbpy_tab[0][0], 2, 1, 1);
1087
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1088
                 &v2_intra_cbpc[0][1], 2, 1,
1089
                 &v2_intra_cbpc[0][0], 2, 1, 1);
1090
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1091
                 &v2_mb_type[0][1], 2, 1,
1092
                 &v2_mb_type[0][0], 2, 1, 1);
1093
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1094
                 &mvtab[0][1], 2, 1,
1095
                 &mvtab[0][0], 2, 1, 1);
1096

    
1097
        for(i=0; i<4; i++){
1098
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1099
                     &wmv2_inter_table[i][0][1], 8, 4,
1100
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1101
        }
1102

    
1103
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1104
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
1105
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1106

    
1107
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1108
                 intra_MCBPC_bits, 1, 1,
1109
                 intra_MCBPC_code, 1, 1, 1);
1110
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1111
                 inter_MCBPC_bits, 1, 1,
1112
                 inter_MCBPC_code, 1, 1, 1);
1113

    
1114
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1115
                 &table_inter_intra[0][1], 2, 1,
1116
                 &table_inter_intra[0][0], 2, 1, 1);
1117
    }
1118

    
1119
    switch(s->msmpeg4_version){
1120
    case 1:
1121
    case 2:
1122
        s->decode_mb= msmpeg4v12_decode_mb;
1123
        break;
1124
    case 3:
1125
    case 4:
1126
        s->decode_mb= msmpeg4v34_decode_mb;
1127
        break;
1128
    case 5:
1129
        s->decode_mb= wmv2_decode_mb;
1130
    case 6:
1131
        //FIXME + TODO VC1 decode mb
1132
        break;
1133
    }
1134

    
1135
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1136

    
1137
    return 0;
1138
}
1139

    
1140
int msmpeg4_decode_picture_header(MpegEncContext * s)
1141
{
1142
    int code;
1143

    
1144
#if 0
1145
{
1146
int i;
1147
for(i=0; i<s->gb.size_in_bits; i++)
1148
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1149
//    get_bits1(&s->gb);
1150
av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1151
return -1;
1152
}
1153
#endif
1154

    
1155
    if(s->msmpeg4_version==1){
1156
        int start_code, num;
1157
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1158
        if(start_code!=0x00000100){
1159
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1160
            return -1;
1161
        }
1162

    
1163
        num= get_bits(&s->gb, 5); // frame number */
1164
    }
1165

    
1166
    s->pict_type = get_bits(&s->gb, 2) + 1;
1167
    if (s->pict_type != I_TYPE &&
1168
        s->pict_type != P_TYPE){
1169
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1170
        return -1;
1171
    }
1172
#if 0
1173
{
1174
    static int had_i=0;
1175
    if(s->pict_type == I_TYPE) had_i=1;
1176
    if(!had_i) return -1;
1177
}
1178
#endif
1179
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1180
    if(s->qscale==0){
1181
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1182
        return -1;
1183
    }
1184

    
1185
    if (s->pict_type == I_TYPE) {
1186
        code = get_bits(&s->gb, 5);
1187
        if(s->msmpeg4_version==1){
1188
            if(code==0 || code>s->mb_height){
1189
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1190
                return -1;
1191
            }
1192

    
1193
            s->slice_height = code;
1194
        }else{
1195
            /* 0x17: one slice, 0x18: two slices, ... */
1196
            if (code < 0x17){
1197
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1198
                return -1;
1199
            }
1200

    
1201
            s->slice_height = s->mb_height / (code - 0x16);
1202
        }
1203

    
1204
        switch(s->msmpeg4_version){
1205
        case 1:
1206
        case 2:
1207
            s->rl_chroma_table_index = 2;
1208
            s->rl_table_index = 2;
1209

    
1210
            s->dc_table_index = 0; //not used
1211
            break;
1212
        case 3:
1213
            s->rl_chroma_table_index = decode012(&s->gb);
1214
            s->rl_table_index = decode012(&s->gb);
1215

    
1216
            s->dc_table_index = get_bits1(&s->gb);
1217
            break;
1218
        case 4:
1219
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1220

    
1221
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1222
            else                           s->per_mb_rl_table= 0;
1223

    
1224
            if(!s->per_mb_rl_table){
1225
                s->rl_chroma_table_index = decode012(&s->gb);
1226
                s->rl_table_index = decode012(&s->gb);
1227
            }
1228

    
1229
            s->dc_table_index = get_bits1(&s->gb);
1230
            s->inter_intra_pred= 0;
1231
            break;
1232
        }
1233
        s->no_rounding = 1;
1234
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1235
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1236
                s->qscale,
1237
                s->rl_chroma_table_index,
1238
                s->rl_table_index,
1239
                s->dc_table_index,
1240
                s->per_mb_rl_table,
1241
                s->slice_height);
1242
    } else {
1243
        switch(s->msmpeg4_version){
1244
        case 1:
1245
        case 2:
1246
            if(s->msmpeg4_version==1)
1247
                s->use_skip_mb_code = 1;
1248
            else
1249
                s->use_skip_mb_code = get_bits1(&s->gb);
1250
            s->rl_table_index = 2;
1251
            s->rl_chroma_table_index = s->rl_table_index;
1252
            s->dc_table_index = 0; //not used
1253
            s->mv_table_index = 0;
1254
            break;
1255
        case 3:
1256
            s->use_skip_mb_code = get_bits1(&s->gb);
1257
            s->rl_table_index = decode012(&s->gb);
1258
            s->rl_chroma_table_index = s->rl_table_index;
1259

    
1260
            s->dc_table_index = get_bits1(&s->gb);
1261

    
1262
            s->mv_table_index = get_bits1(&s->gb);
1263
            break;
1264
        case 4:
1265
            s->use_skip_mb_code = get_bits1(&s->gb);
1266

    
1267
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1268
            else                           s->per_mb_rl_table= 0;
1269

    
1270
            if(!s->per_mb_rl_table){
1271
                s->rl_table_index = decode012(&s->gb);
1272
                s->rl_chroma_table_index = s->rl_table_index;
1273
            }
1274

    
1275
            s->dc_table_index = get_bits1(&s->gb);
1276

    
1277
            s->mv_table_index = get_bits1(&s->gb);
1278
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1279
            break;
1280
        }
1281

    
1282
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1283
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1284
                s->use_skip_mb_code,
1285
                s->rl_table_index,
1286
                s->rl_chroma_table_index,
1287
                s->dc_table_index,
1288
                s->mv_table_index,
1289
                s->per_mb_rl_table,
1290
                s->qscale);
1291

    
1292
        if(s->flipflop_rounding){
1293
            s->no_rounding ^= 1;
1294
        }else{
1295
            s->no_rounding = 0;
1296
        }
1297
    }
1298
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1299

    
1300
    s->esc3_level_length= 0;
1301
    s->esc3_run_length= 0;
1302

    
1303
#ifdef DEBUG
1304
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1305
#endif
1306
    return 0;
1307
}
1308

    
1309
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1310
{
1311
    int left= buf_size*8 - get_bits_count(&s->gb);
1312
    int length= s->msmpeg4_version>=3 ? 17 : 16;
1313
    /* the alt_bitstream reader could read over the end so we need to check it */
1314
    if(left>=length && left<length+8)
1315
    {
1316
        int fps;
1317

    
1318
        fps= get_bits(&s->gb, 5);
1319
        s->bit_rate= get_bits(&s->gb, 11)*1024;
1320
        if(s->msmpeg4_version>=3)
1321
            s->flipflop_rounding= get_bits1(&s->gb);
1322
        else
1323
            s->flipflop_rounding= 0;
1324

    
1325
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1326
    }
1327
    else if(left<length+8)
1328
    {
1329
        s->flipflop_rounding= 0;
1330
        if(s->msmpeg4_version != 2)
1331
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1332
    }
1333
    else
1334
    {
1335
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1336
    }
1337

    
1338
    return 0;
1339
}
1340

    
1341
static inline void msmpeg4_memsetw(short *tab, int val, int n)
1342
{
1343
    int i;
1344
    for(i=0;i<n;i++)
1345
        tab[i] = val;
1346
}
1347

    
1348
#ifdef CONFIG_ENCODERS
1349
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1350
{
1351
    int range, bit_size, sign, code, bits;
1352

    
1353
    if (val == 0) {
1354
        /* zero vector */
1355
        code = 0;
1356
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1357
    } else {
1358
        bit_size = s->f_code - 1;
1359
        range = 1 << bit_size;
1360
        if (val <= -64)
1361
            val += 64;
1362
        else if (val >= 64)
1363
            val -= 64;
1364

    
1365
        if (val >= 0) {
1366
            sign = 0;
1367
        } else {
1368
            val = -val;
1369
            sign = 1;
1370
        }
1371
        val--;
1372
        code = (val >> bit_size) + 1;
1373
        bits = val & (range - 1);
1374

    
1375
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1376
        if (bit_size > 0) {
1377
            put_bits(&s->pb, bit_size, bits);
1378
        }
1379
    }
1380
}
1381
#endif
1382

    
1383
/* this is identical to h263 except that its range is multiplied by 2 */
1384
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1385
{
1386
    int code, val, sign, shift;
1387

    
1388
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1389
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1390
    if (code < 0)
1391
        return 0xffff;
1392

    
1393
    if (code == 0)
1394
        return pred;
1395
    sign = get_bits1(&s->gb);
1396
    shift = f_code - 1;
1397
    val = code;
1398
    if (shift) {
1399
        val = (val - 1) << shift;
1400
        val |= get_bits(&s->gb, shift);
1401
        val++;
1402
    }
1403
    if (sign)
1404
        val = -val;
1405

    
1406
    val += pred;
1407
    if (val <= -64)
1408
        val += 64;
1409
    else if (val >= 64)
1410
        val -= 64;
1411

    
1412
    return val;
1413
}
1414

    
1415
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1416
{
1417
    int cbp, code, i;
1418

    
1419
    if (s->pict_type == P_TYPE) {
1420
        if (s->use_skip_mb_code) {
1421
            if (get_bits1(&s->gb)) {
1422
                /* skip mb */
1423
                s->mb_intra = 0;
1424
                for(i=0;i<6;i++)
1425
                    s->block_last_index[i] = -1;
1426
                s->mv_dir = MV_DIR_FORWARD;
1427
                s->mv_type = MV_TYPE_16X16;
1428
                s->mv[0][0][0] = 0;
1429
                s->mv[0][0][1] = 0;
1430
                s->mb_skipped = 1;
1431
                return 0;
1432
            }
1433
        }
1434

    
1435
        if(s->msmpeg4_version==2)
1436
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1437
        else
1438
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1439
        if(code<0 || code>7){
1440
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1441
            return -1;
1442
        }
1443

    
1444
        s->mb_intra = code >>2;
1445

    
1446
        cbp = code & 0x3;
1447
    } else {
1448
        s->mb_intra = 1;
1449
        if(s->msmpeg4_version==2)
1450
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1451
        else
1452
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1453
        if(cbp<0 || cbp>3){
1454
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1455
            return -1;
1456
        }
1457
    }
1458

    
1459
    if (!s->mb_intra) {
1460
        int mx, my, cbpy;
1461

    
1462
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1463
        if(cbpy<0){
1464
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1465
            return -1;
1466
        }
1467

    
1468
        cbp|= cbpy<<2;
1469
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1470

    
1471
        h263_pred_motion(s, 0, 0, &mx, &my);
1472
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1473
        my= msmpeg4v2_decode_motion(s, my, 1);
1474

    
1475
        s->mv_dir = MV_DIR_FORWARD;
1476
        s->mv_type = MV_TYPE_16X16;
1477
        s->mv[0][0][0] = mx;
1478
        s->mv[0][0][1] = my;
1479
    } else {
1480
        if(s->msmpeg4_version==2){
1481
            s->ac_pred = get_bits1(&s->gb);
1482
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1483
        } else{
1484
            s->ac_pred = 0;
1485
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1486
            if(s->pict_type==P_TYPE) cbp^=0x3C;
1487
        }
1488
    }
1489

    
1490
    s->dsp.clear_blocks(s->block[0]);
1491
    for (i = 0; i < 6; i++) {
1492
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1493
        {
1494
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1495
             return -1;
1496
        }
1497
    }
1498
    return 0;
1499
}
1500

    
1501
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1502
{
1503
    int cbp, code, i;
1504
    uint8_t *coded_val;
1505
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1506

    
1507
    if (s->pict_type == P_TYPE) {
1508
        if (s->use_skip_mb_code) {
1509
            if (get_bits1(&s->gb)) {
1510
                /* skip mb */
1511
                s->mb_intra = 0;
1512
                for(i=0;i<6;i++)
1513
                    s->block_last_index[i] = -1;
1514
                s->mv_dir = MV_DIR_FORWARD;
1515
                s->mv_type = MV_TYPE_16X16;
1516
                s->mv[0][0][0] = 0;
1517
                s->mv[0][0][1] = 0;
1518
                s->mb_skipped = 1;
1519
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1520

    
1521
                return 0;
1522
            }
1523
        }
1524

    
1525
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1526
        if (code < 0)
1527
            return -1;
1528
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1529
        s->mb_intra = (~code & 0x40) >> 6;
1530

    
1531
        cbp = code & 0x3f;
1532
    } else {
1533
        s->mb_intra = 1;
1534
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1535
        if (code < 0)
1536
            return -1;
1537
        /* predict coded block pattern */
1538
        cbp = 0;
1539
        for(i=0;i<6;i++) {
1540
            int val = ((code >> (5 - i)) & 1);
1541
            if (i < 4) {
1542
                int pred = coded_block_pred(s, i, &coded_val);
1543
                val = val ^ pred;
1544
                *coded_val = val;
1545
            }
1546
            cbp |= val << (5 - i);
1547
        }
1548
    }
1549

    
1550
    if (!s->mb_intra) {
1551
        int mx, my;
1552
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1553
        if(s->per_mb_rl_table && cbp){
1554
            s->rl_table_index = decode012(&s->gb);
1555
            s->rl_chroma_table_index = s->rl_table_index;
1556
        }
1557
        h263_pred_motion(s, 0, 0, &mx, &my);
1558
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1559
            return -1;
1560
        s->mv_dir = MV_DIR_FORWARD;
1561
        s->mv_type = MV_TYPE_16X16;
1562
        s->mv[0][0][0] = mx;
1563
        s->mv[0][0][1] = my;
1564
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1565
    } else {
1566
//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));
1567
        s->ac_pred = get_bits1(&s->gb);
1568
        *mb_type_ptr = MB_TYPE_INTRA;
1569
        if(s->inter_intra_pred){
1570
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1571
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1572
        }
1573
        if(s->per_mb_rl_table && cbp){
1574
            s->rl_table_index = decode012(&s->gb);
1575
            s->rl_chroma_table_index = s->rl_table_index;
1576
        }
1577
    }
1578

    
1579
    s->dsp.clear_blocks(s->block[0]);
1580
    for (i = 0; i < 6; i++) {
1581
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1582
        {
1583
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1584
            return -1;
1585
        }
1586
    }
1587

    
1588
    return 0;
1589
}
1590
//#define ERROR_DETAILS
1591
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1592
                              int n, int coded, const uint8_t *scan_table)
1593
{
1594
    int level, i, last, run, run_diff;
1595
    int dc_pred_dir;
1596
    RLTable *rl;
1597
    RL_VLC_ELEM *rl_vlc;
1598
    int qmul, qadd;
1599

    
1600
    if (s->mb_intra) {
1601
        qmul=1;
1602
        qadd=0;
1603

    
1604
        /* DC coef */
1605
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1606

    
1607
        if (level < 0){
1608
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1609
            if(s->inter_intra_pred) level=0;
1610
            else                    return -1;
1611
        }
1612
        if (n < 4) {
1613
            rl = &rl_table[s->rl_table_index];
1614
            if(level > 256*s->y_dc_scale){
1615
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1616
                if(!s->inter_intra_pred) return -1;
1617
            }
1618
        } else {
1619
            rl = &rl_table[3 + s->rl_chroma_table_index];
1620
            if(level > 256*s->c_dc_scale){
1621
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1622
                if(!s->inter_intra_pred) return -1;
1623
            }
1624
        }
1625
        block[0] = level;
1626

    
1627
        run_diff = 0;
1628
        i = 0;
1629
        if (!coded) {
1630
            goto not_coded;
1631
        }
1632
        if (s->ac_pred) {
1633
            if (dc_pred_dir == 0)
1634
                scan_table = s->intra_v_scantable.permutated; /* left */
1635
            else
1636
                scan_table = s->intra_h_scantable.permutated; /* top */
1637
        } else {
1638
            scan_table = s->intra_scantable.permutated;
1639
        }
1640
        rl_vlc= rl->rl_vlc[0];
1641
    } else {
1642
        qmul = s->qscale << 1;
1643
        qadd = (s->qscale - 1) | 1;
1644
        i = -1;
1645
        rl = &rl_table[3 + s->rl_table_index];
1646

    
1647
        if(s->msmpeg4_version==2)
1648
            run_diff = 0;
1649
        else
1650
            run_diff = 1;
1651

    
1652
        if (!coded) {
1653
            s->block_last_index[n] = i;
1654
            return 0;
1655
        }
1656
        if(!scan_table)
1657
            scan_table = s->inter_scantable.permutated;
1658
        rl_vlc= rl->rl_vlc[s->qscale];
1659
    }
1660
  {
1661
    OPEN_READER(re, &s->gb);
1662
    for(;;) {
1663
        UPDATE_CACHE(re, &s->gb);
1664
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1665
        if (level==0) {
1666
            int cache;
1667
            cache= GET_CACHE(re, &s->gb);
1668
            /* escape */
1669
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1670
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1671
                    /* third escape */
1672
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1673
                    UPDATE_CACHE(re, &s->gb);
1674
                    if(s->msmpeg4_version<=3){
1675
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1676
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1677
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1678
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
1679
                    }else{
1680
                        int sign;
1681
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1682
                        if(!s->esc3_level_length){
1683
                            int ll;
1684
                            //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1685
                            if(s->qscale<8){
1686
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1687
                                if(ll==0){
1688
                                    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");
1689
                                    SKIP_BITS(re, &s->gb, 1);
1690
                                    ll=8;
1691
                                }
1692
                            }else{
1693
                                ll=2;
1694
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1695
                                    ll++;
1696
                                    SKIP_BITS(re, &s->gb, 1);
1697
                                }
1698
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
1699
                            }
1700

    
1701
                            s->esc3_level_length= ll;
1702
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1703
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1704
                            UPDATE_CACHE(re, &s->gb);
1705
                        }
1706
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1707
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
1708

    
1709
                        sign=  SHOW_UBITS(re, &s->gb, 1);
1710
                        SKIP_BITS(re, &s->gb, 1);
1711

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

    
1817
            block[scan_table[i]] = level;
1818
            break;
1819
        }
1820

    
1821
        block[scan_table[i]] = level;
1822
    }
1823
    CLOSE_READER(re, &s->gb);
1824
  }
1825
 not_coded:
1826
    if (s->mb_intra) {
1827
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1828
        if (s->ac_pred) {
1829
            i = 63; /* XXX: not optimal */
1830
        }
1831
    }
1832
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1833
    s->block_last_index[n] = i;
1834

    
1835
    return 0;
1836
}
1837

    
1838
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1839
{
1840
    int level, pred;
1841

    
1842
    if(s->msmpeg4_version<=2){
1843
        if (n < 4) {
1844
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1845
        } else {
1846
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1847
        }
1848
        if (level < 0)
1849
            return -1;
1850
        level-=256;
1851
    }else{  //FIXME optimize use unified tables & index
1852
        if (n < 4) {
1853
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1854
        } else {
1855
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1856
        }
1857
        if (level < 0){
1858
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1859
            return -1;
1860
        }
1861

    
1862
        if (level == DC_MAX) {
1863
            level = get_bits(&s->gb, 8);
1864
            if (get_bits1(&s->gb))
1865
                level = -level;
1866
        } else if (level != 0) {
1867
            if (get_bits1(&s->gb))
1868
                level = -level;
1869
        }
1870
    }
1871

    
1872
    if(s->msmpeg4_version==1){
1873
        int32_t *dc_val;
1874
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1875
        level += pred;
1876

    
1877
        /* update predictor */
1878
        *dc_val= level;
1879
    }else{
1880
        int16_t *dc_val;
1881
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1882
        level += pred;
1883

    
1884
        /* update predictor */
1885
        if (n < 4) {
1886
            *dc_val = level * s->y_dc_scale;
1887
        } else {
1888
            *dc_val = level * s->c_dc_scale;
1889
        }
1890
    }
1891

    
1892
    return level;
1893
}
1894

    
1895
static int msmpeg4_decode_motion(MpegEncContext * s,
1896
                                 int *mx_ptr, int *my_ptr)
1897
{
1898
    MVTable *mv;
1899
    int code, mx, my;
1900

    
1901
    mv = &mv_tables[s->mv_table_index];
1902

    
1903
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1904
    if (code < 0){
1905
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1906
        return -1;
1907
    }
1908
    if (code == mv->n) {
1909
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1910
        mx = get_bits(&s->gb, 6);
1911
        my = get_bits(&s->gb, 6);
1912
    } else {
1913
        mx = mv->table_mvx[code];
1914
        my = mv->table_mvy[code];
1915
    }
1916

    
1917
    mx += *mx_ptr - 32;
1918
    my += *my_ptr - 32;
1919
    /* WARNING : they do not do exactly modulo encoding */
1920
    if (mx <= -64)
1921
        mx += 64;
1922
    else if (mx >= 64)
1923
        mx -= 64;
1924

    
1925
    if (my <= -64)
1926
        my += 64;
1927
    else if (my >= 64)
1928
        my -= 64;
1929
    *mx_ptr = mx;
1930
    *my_ptr = my;
1931
    return 0;
1932
}
1933

    
1934
/* cleanest way to support it
1935
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1936
 * as allmost everything would be in the common file
1937
 */
1938
#include "wmv2.c"