Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ f2d702e1

History | View | Annotate | Download (61.1 KB)

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

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

    
30
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33
#include "msmpeg4.h"
34
#include "libavutil/x86_cpu.h"
35

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

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

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

    
58
#define DEFAULT_INTER_INDEX 3
59

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

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

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

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

    
80
#include "msmpeg4data.h"
81

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

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

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

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

    
119
    }
120

    
121

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

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

    
133
        init_h263_dc_for_msmpeg4();
134
    }
135
}
136

    
137
#if CONFIG_ENCODERS
138

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
306
}
307

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

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

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

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

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

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

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

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

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

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

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

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

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

    
368
void msmpeg4_encode_ext_header(MpegEncContext * s)
369
{
370
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
371

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

    
374
        if(s->msmpeg4_version>=3)
375
            put_bits(&s->pb, 1, s->flipflop_rounding);
376
        else
377
            assert(s->flipflop_rounding==0);
378
}
379

    
380
#endif //CONFIG_ENCODERS
381

    
382
/* predict coded block */
383
int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
384
{
385
    int xy, wrap, pred, a, b, c;
386

    
387
    xy = s->block_index[n];
388
    wrap = s->b8_stride;
389

    
390
    /* B C
391
     * A X
392
     */
393
    a = s->coded_block[xy - 1       ];
394
    b = s->coded_block[xy - 1 - wrap];
395
    c = s->coded_block[xy     - wrap];
396

    
397
    if (b == c) {
398
        pred = a;
399
    } else {
400
        pred = c;
401
    }
402

    
403
    /* store value */
404
    *coded_block_ptr = &s->coded_block[xy];
405

    
406
    return pred;
407
}
408

    
409
#if CONFIG_ENCODERS
410

    
411
void ff_msmpeg4_encode_motion(MpegEncContext * s,
412
                                  int mx, int my)
413
{
414
    int code;
415
    MVTable *mv;
416

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

    
429
    mx += 32;
430
    my += 32;
431
#if 0
432
    if ((unsigned)mx >= 64 ||
433
        (unsigned)my >= 64)
434
        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
435
#endif
436
    mv = &mv_tables[s->mv_table_index];
437

    
438
    code = mv->table_mv_index[(mx << 6) | my];
439
    put_bits(&s->pb,
440
             mv->table_mv_bits[code],
441
             mv->table_mv_code[code]);
442
    if (code == mv->n) {
443
        /* escape : code literally */
444
        put_bits(&s->pb, 6, mx);
445
        put_bits(&s->pb, 6, my);
446
    }
447
}
448

    
449
void ff_msmpeg4_handle_slices(MpegEncContext *s){
450
    if (s->mb_x == 0) {
451
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
452
            if(s->msmpeg4_version < 4){
453
                ff_mpeg4_clean_buffers(s);
454
            }
455
            s->first_slice_line = 1;
456
        } else {
457
            s->first_slice_line = 0;
458
        }
459
    }
460
}
461

    
462
void msmpeg4_encode_mb(MpegEncContext * s,
463
                       DCTELEM block[6][64],
464
                       int motion_x, int motion_y)
465
{
466
    int cbp, coded_cbp, i;
467
    int pred_x, pred_y;
468
    uint8_t *coded_block;
469

    
470
    ff_msmpeg4_handle_slices(s);
471

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

    
486
            return;
487
        }
488
        if (s->use_skip_mb_code)
489
            put_bits(&s->pb, 1, 0);     /* mb coded */
490

    
491
        if(s->msmpeg4_version<=2){
492
            put_bits(&s->pb,
493
                     v2_mb_type[cbp&3][1],
494
                     v2_mb_type[cbp&3][0]);
495
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
496
            else             coded_cbp= cbp;
497

    
498
            put_bits(&s->pb,
499
                     cbpy_tab[coded_cbp>>2][1],
500
                     cbpy_tab[coded_cbp>>2][0]);
501

    
502
            s->misc_bits += get_bits_diff(s);
503

    
504
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
505
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
506
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
507
        }else{
508
            put_bits(&s->pb,
509
                     table_mb_non_intra[cbp + 64][1],
510
                     table_mb_non_intra[cbp + 64][0]);
511

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

    
514
            /* motion vector */
515
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
516
            ff_msmpeg4_encode_motion(s, motion_x - pred_x,
517
                                  motion_y - pred_y);
518
        }
519

    
520
        s->mv_bits += get_bits_diff(s);
521

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

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

    
581
        for (i = 0; i < 6; i++) {
582
            ff_msmpeg4_encode_block(s, block[i], i);
583
        }
584
        s->i_tex_bits += get_bits_diff(s);
585
        s->i_count++;
586
    }
587
}
588

    
589
#endif //CONFIG_ENCODERS
590

    
591
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
592
                                    int32_t **dc_val_ptr)
593
{
594
    int i;
595

    
596
    if (n < 4) {
597
        i= 0;
598
    } else {
599
        i= n-3;
600
    }
601

    
602
    *dc_val_ptr= &s->last_dc[i];
603
    return s->last_dc[i];
604
}
605

    
606
static int get_dc(uint8_t *src, int stride, int scale)
607
{
608
    int y;
609
    int sum=0;
610
    for(y=0; y<8; y++){
611
        int x;
612
        for(x=0; x<8; x++){
613
            sum+=src[x + y*stride];
614
        }
615
    }
616
    return FASTDIV((sum + (scale>>1)), scale);
617
}
618

    
619
/* dir = 0: left, dir = 1: top prediction */
620
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
621
                             int16_t **dc_val_ptr, int *dir_ptr)
622
{
623
    int a, b, c, wrap, pred, scale;
624
    int16_t *dc_val;
625

    
626
    /* find prediction */
627
    if (n < 4) {
628
        scale = s->y_dc_scale;
629
    } else {
630
        scale = s->c_dc_scale;
631
    }
632

    
633
    wrap = s->block_wrap[n];
634
    dc_val= s->dc_val[0] + s->block_index[n];
635

    
636
    /* B C
637
     * A X
638
     */
639
    a = dc_val[ - 1];
640
    b = dc_val[ - 1 - wrap];
641
    c = dc_val[ - wrap];
642

    
643
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
644
        b=c=1024;
645
    }
646

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

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

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

    
762
    /* update predictor */
763
    *dc_val_ptr = &dc_val[0];
764
    return pred;
765
}
766

    
767
#define DC_MAX 119
768

    
769
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
770
{
771
    int sign, code;
772
    int pred, extquant;
773
    int extrabits = 0;
774

    
775
    if(s->msmpeg4_version==1){
776
        int32_t *dc_val;
777
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
778

    
779
        /* update predictor */
780
        *dc_val= level;
781
    }else{
782
        int16_t *dc_val;
783
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
784

    
785
        /* update predictor */
786
        if (n < 4) {
787
            *dc_val = level * s->y_dc_scale;
788
        } else {
789
            *dc_val = level * s->c_dc_scale;
790
        }
791
    }
792

    
793
    /* do the prediction */
794
    level -= pred;
795

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

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

    
839
        if(s->msmpeg4_version>=6 && s->qscale<=2)
840
            extrabits = 3 - s->qscale;
841

    
842
        if (code == DC_MAX)
843
            put_bits(&s->pb, 8 + extrabits, level);
844
        else if(extrabits > 0)//== VC1 && s->qscale<=2
845
            put_bits(&s->pb, extrabits, extquant);
846

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

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

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

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

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

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

    
977
/****************************************/
978
/* decoding stuff */
979

    
980
VLC ff_mb_non_intra_vlc[4];
981
static VLC v2_dc_lum_vlc;
982
static VLC v2_dc_chroma_vlc;
983
static VLC cbpy_vlc;
984
static VLC v2_intra_cbpc_vlc;
985
static VLC v2_mb_type_vlc;
986
static VLC v2_mv_vlc;
987
static VLC v1_intra_cbpc_vlc;
988
static VLC v1_inter_cbpc_vlc;
989
VLC ff_inter_intra_vlc;
990

    
991
/* This table is practically identical to the one from h263
992
 * except that it is inverted. */
993
static av_cold void init_h263_dc_for_msmpeg4(void)
994
{
995
        int level, uni_code, uni_len;
996

    
997
        for(level=-256; level<256; level++){
998
            int size, v, l;
999
            /* find number of bits */
1000
            size = 0;
1001
            v = abs(level);
1002
            while (v) {
1003
                v >>= 1;
1004
                    size++;
1005
            }
1006

    
1007
            if (level < 0)
1008
                l= (-level) ^ ((1 << size) - 1);
1009
            else
1010
                l= level;
1011

    
1012
            /* luminance h263 */
1013
            uni_code= DCtab_lum[size][0];
1014
            uni_len = DCtab_lum[size][1];
1015
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1016

    
1017
            if (size > 0) {
1018
                uni_code<<=size; uni_code|=l;
1019
                uni_len+=size;
1020
                if (size > 8){
1021
                    uni_code<<=1; uni_code|=1;
1022
                    uni_len++;
1023
                }
1024
            }
1025
            v2_dc_lum_table[level+256][0]= uni_code;
1026
            v2_dc_lum_table[level+256][1]= uni_len;
1027

    
1028
            /* chrominance h263 */
1029
            uni_code= DCtab_chrom[size][0];
1030
            uni_len = DCtab_chrom[size][1];
1031
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1032

    
1033
            if (size > 0) {
1034
                uni_code<<=size; uni_code|=l;
1035
                uni_len+=size;
1036
                if (size > 8){
1037
                    uni_code<<=1; uni_code|=1;
1038
                    uni_len++;
1039
                }
1040
            }
1041
            v2_dc_chroma_table[level+256][0]= uni_code;
1042
            v2_dc_chroma_table[level+256][1]= uni_len;
1043

    
1044
        }
1045
}
1046

    
1047
/* init all vlc decoding tables */
1048
av_cold int ff_msmpeg4_decode_init(MpegEncContext *s)
1049
{
1050
    static int done = 0;
1051
    int i;
1052
    MVTable *mv;
1053

    
1054
    common_init(s);
1055

    
1056
    if (!done) {
1057
        done = 1;
1058

    
1059
        for(i=0;i<NB_RL_TABLES;i++) {
1060
            init_rl(&rl_table[i], static_rl_table_store[i]);
1061
        }
1062
        INIT_VLC_RL(rl_table[0], 642);
1063
        INIT_VLC_RL(rl_table[1], 1104);
1064
        INIT_VLC_RL(rl_table[2], 554);
1065
        INIT_VLC_RL(rl_table[3], 940);
1066
        INIT_VLC_RL(rl_table[4], 962);
1067
        INIT_VLC_RL(rl_table[5], 554);
1068

    
1069
        mv = &mv_tables[0];
1070
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1071
                    mv->table_mv_bits, 1, 1,
1072
                    mv->table_mv_code, 2, 2, 3714);
1073
        mv = &mv_tables[1];
1074
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1075
                    mv->table_mv_bits, 1, 1,
1076
                    mv->table_mv_code, 2, 2, 2694);
1077

    
1078
        INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1079
                 &ff_table0_dc_lum[0][1], 8, 4,
1080
                 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1081
        INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1082
                 &ff_table0_dc_chroma[0][1], 8, 4,
1083
                 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1084
        INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1085
                 &ff_table1_dc_lum[0][1], 8, 4,
1086
                 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1087
        INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1088
                 &ff_table1_dc_chroma[0][1], 8, 4,
1089
                 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1090

    
1091
        INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1092
                 &v2_dc_lum_table[0][1], 8, 4,
1093
                 &v2_dc_lum_table[0][0], 8, 4, 1472);
1094
        INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1095
                 &v2_dc_chroma_table[0][1], 8, 4,
1096
                 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1097

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

    
1111
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1112
                     &wmv2_inter_table[0][0][1], 8, 4,
1113
                     &wmv2_inter_table[0][0][0], 8, 4, 1636);
1114
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1115
                     &wmv2_inter_table[1][0][1], 8, 4,
1116
                     &wmv2_inter_table[1][0][0], 8, 4, 2648);
1117
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1118
                     &wmv2_inter_table[2][0][1], 8, 4,
1119
                     &wmv2_inter_table[2][0][0], 8, 4, 1532);
1120
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1121
                     &wmv2_inter_table[3][0][1], 8, 4,
1122
                     &wmv2_inter_table[3][0][0], 8, 4, 2488);
1123

    
1124
        INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1125
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
1126
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1127

    
1128
        INIT_VLC_STATIC(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1129
                 intra_MCBPC_bits, 1, 1,
1130
                 intra_MCBPC_code, 1, 1, 64);
1131
        INIT_VLC_STATIC(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1132
                 inter_MCBPC_bits, 1, 1,
1133
                 inter_MCBPC_code, 1, 1, 104);
1134

    
1135
        INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1136
                 &table_inter_intra[0][1], 2, 1,
1137
                 &table_inter_intra[0][0], 2, 1, 8);
1138
    }
1139

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

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

    
1159
    return 0;
1160
}
1161

    
1162
int msmpeg4_decode_picture_header(MpegEncContext * s)
1163
{
1164
    int code;
1165

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

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

    
1185
        skip_bits(&s->gb, 5); // frame number */
1186
    }
1187

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

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

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

    
1223
            s->slice_height = s->mb_height / (code - 0x16);
1224
        }
1225

    
1226
        switch(s->msmpeg4_version){
1227
        case 1:
1228
        case 2:
1229
            s->rl_chroma_table_index = 2;
1230
            s->rl_table_index = 2;
1231

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

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

    
1243
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1244
            else                           s->per_mb_rl_table= 0;
1245

    
1246
            if(!s->per_mb_rl_table){
1247
                s->rl_chroma_table_index = decode012(&s->gb);
1248
                s->rl_table_index = decode012(&s->gb);
1249
            }
1250

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

    
1282
            s->dc_table_index = get_bits1(&s->gb);
1283

    
1284
            s->mv_table_index = get_bits1(&s->gb);
1285
            break;
1286
        case 4:
1287
            s->use_skip_mb_code = get_bits1(&s->gb);
1288

    
1289
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1290
            else                           s->per_mb_rl_table= 0;
1291

    
1292
            if(!s->per_mb_rl_table){
1293
                s->rl_table_index = decode012(&s->gb);
1294
                s->rl_chroma_table_index = s->rl_table_index;
1295
            }
1296

    
1297
            s->dc_table_index = get_bits1(&s->gb);
1298

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

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

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

    
1322
    s->esc3_level_length= 0;
1323
    s->esc3_run_length= 0;
1324

    
1325
    return 0;
1326
}
1327

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

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

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

    
1357
    return 0;
1358
}
1359

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

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

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

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

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

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

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

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

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

    
1431
    return val;
1432
}
1433

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1540
                return 0;
1541
            }
1542
        }
1543

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1854
    return 0;
1855
}
1856

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

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

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

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

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

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

    
1911
    return level;
1912
}
1913

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

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

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

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

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