Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 36cd3069

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

    
90
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its 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 void common_init(MpegEncContext * s)
95
{
96
    static int inited=0;
97

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

    
125
    }
126

    
127

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

    
136
    if(!inited){
137
        inited=1;
138

    
139
        init_h263_dc_for_msmpeg4();
140
    }
141
}
142

    
143
#ifdef CONFIG_ENCODERS
144

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
297
    if(s->pict_type==P_TYPE) chroma_best= best;
298

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

    
301
    s->rl_table_index       =        best;
302
    s->rl_chroma_table_index= chroma_best;
303

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

    
312
}
313

    
314
/* write MSMPEG4 compatible frame header */
315
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
316
{
317
    find_best_tables(s);
318

    
319
    align_put_bits(&s->pb);
320
    put_bits(&s->pb, 2, s->pict_type - 1);
321

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

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

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

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

    
346
        if(s->msmpeg4_version>2){
347
            if(!s->per_mb_rl_table){
348
                code012(&s->pb, s->rl_chroma_table_index);
349
                code012(&s->pb, s->rl_table_index);
350
            }
351

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

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

    
360
        if(s->msmpeg4_version>2){
361
            if(!s->per_mb_rl_table)
362
                code012(&s->pb, s->rl_table_index);
363

    
364
            put_bits(&s->pb, 1, s->dc_table_index);
365

    
366
            put_bits(&s->pb, 1, s->mv_table_index);
367
        }
368
    }
369

    
370
    s->esc3_level_length= 0;
371
    s->esc3_run_length= 0;
372

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

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

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

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

    
391
#endif //CONFIG_ENCODERS
392

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

    
398
    xy = s->block_index[n];
399
    wrap = s->b8_stride;
400

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

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

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

    
417
    return pred;
418
}
419

    
420
#ifdef CONFIG_ENCODERS
421

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

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

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

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

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

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

    
481
    handle_slices(s);
482

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

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

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

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

    
513
            s->misc_bits += get_bits_diff(s);
514

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

    
523
            s->misc_bits += get_bits_diff(s);
524

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

    
531
        s->mv_bits += get_bits_diff(s);
532

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

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

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

    
600
#endif //CONFIG_ENCODERS
601

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

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

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

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

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

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

    
644
    wrap = s->block_wrap[n];
645
    dc_val= s->dc_val[0] + s->block_index[n];
646

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

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

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

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

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

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

    
778
#define DC_MAX 119
779

    
780
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
781
{
782
    int sign, code;
783
    int pred;
784

    
785
    if(s->msmpeg4_version==1){
786
        int32_t *dc_val;
787
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
788

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

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

    
803
    /* do the prediction */
804
    level -= pred;
805

    
806
    if(s->msmpeg4_version<=2){
807
        if (n < 4) {
808
            put_bits(&s->pb,
809
                     v2_dc_lum_table[level+256][1],
810
                     v2_dc_lum_table[level+256][0]);
811
        }else{
812
            put_bits(&s->pb,
813
                     v2_dc_chroma_table[level+256][1],
814
                     v2_dc_chroma_table[level+256][0]);
815
        }
816
    }else{
817
        sign = 0;
818
        if (level < 0) {
819
            level = -level;
820
            sign = 1;
821
        }
822
        code = level;
823
        if (code > DC_MAX)
824
            code = DC_MAX;
825

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

    
840
        if (code == DC_MAX)
841
            put_bits(&s->pb, 8, level);
842

    
843
        if (level != 0) {
844
            put_bits(&s->pb, 1, sign);
845
        }
846
    }
847
}
848

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

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

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

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

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

    
969
/****************************************/
970
/* decoding stuff */
971

    
972
static VLC mb_non_intra_vlc[4];
973
VLC ff_msmp4_mb_i_vlc;
974
VLC ff_msmp4_dc_luma_vlc[2];
975
VLC ff_msmp4_dc_chroma_vlc[2];
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], 1);
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"