Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ ce5e49b0

History | View | Annotate | Download (60.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
 * 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
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
#include "h263.h"
36
#include "mpeg4video.h"
37

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

    
47
#define DC_VLC_BITS 9
48
#define V2_INTRA_CBPC_VLC_BITS 3
49
#define V2_MB_TYPE_VLC_BITS 7
50
#define MV_VLC_BITS 9
51
#define V2_MV_VLC_BITS 9
52
#define TEX_VLC_BITS 9
53

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

    
57
#define DEFAULT_INTER_INDEX 3
58

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

    
62
/* vc1 externs */
63
extern const uint8_t wmv3_dc_scale_table[32];
64

    
65
#ifdef DEBUG
66
int frame_count = 0;
67
#endif
68

    
69
#include "msmpeg4data.h"
70

    
71
#if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced
72
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
73
#endif //CONFIG_ENCODERS
74

    
75
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
76

    
77
/* This table is practically identical to the one from h263
78
 * except that it is inverted. */
79
static av_cold void init_h263_dc_for_msmpeg4(void)
80
{
81
        int level, uni_code, uni_len;
82

    
83
        for(level=-256; level<256; level++){
84
            int size, v, l;
85
            /* find number of bits */
86
            size = 0;
87
            v = abs(level);
88
            while (v) {
89
                v >>= 1;
90
                    size++;
91
            }
92

    
93
            if (level < 0)
94
                l= (-level) ^ ((1 << size) - 1);
95
            else
96
                l= level;
97

    
98
            /* luminance h263 */
99
            uni_code= ff_mpeg4_DCtab_lum[size][0];
100
            uni_len = ff_mpeg4_DCtab_lum[size][1];
101
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
102

    
103
            if (size > 0) {
104
                uni_code<<=size; uni_code|=l;
105
                uni_len+=size;
106
                if (size > 8){
107
                    uni_code<<=1; uni_code|=1;
108
                    uni_len++;
109
                }
110
            }
111
            v2_dc_lum_table[level+256][0]= uni_code;
112
            v2_dc_lum_table[level+256][1]= uni_len;
113

    
114
            /* chrominance h263 */
115
            uni_code= ff_mpeg4_DCtab_chrom[size][0];
116
            uni_len = ff_mpeg4_DCtab_chrom[size][1];
117
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
118

    
119
            if (size > 0) {
120
                uni_code<<=size; uni_code|=l;
121
                uni_len+=size;
122
                if (size > 8){
123
                    uni_code<<=1; uni_code|=1;
124
                    uni_len++;
125
                }
126
            }
127
            v2_dc_chroma_table[level+256][0]= uni_code;
128
            v2_dc_chroma_table[level+256][1]= uni_len;
129

    
130
        }
131
}
132

    
133
static av_cold void common_init(MpegEncContext * s)
134
{
135
    static int initialized=0;
136

    
137
    switch(s->msmpeg4_version){
138
    case 1:
139
    case 2:
140
        s->y_dc_scale_table=
141
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
142
        break;
143
    case 3:
144
        if(s->workaround_bugs){
145
            s->y_dc_scale_table= old_ff_y_dc_scale_table;
146
            s->c_dc_scale_table= wmv1_c_dc_scale_table;
147
        } else{
148
            s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
149
            s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
150
        }
151
        break;
152
    case 4:
153
    case 5:
154
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
155
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
156
        break;
157
#if CONFIG_VC1_DECODER
158
    case 6:
159
        s->y_dc_scale_table= wmv3_dc_scale_table;
160
        s->c_dc_scale_table= wmv3_dc_scale_table;
161
        break;
162
#endif
163

    
164
    }
165

    
166

    
167
    if(s->msmpeg4_version>=4){
168
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
169
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
170
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
171
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
172
    }
173
    //Note the default tables are set in common_init in mpegvideo.c
174

    
175
    if(!initialized){
176
        initialized=1;
177

    
178
        init_h263_dc_for_msmpeg4();
179
    }
180
}
181

    
182
#if CONFIG_ENCODERS
183

    
184
/* build the table which associate a (x,y) motion vector to a vlc */
185
static void init_mv_table(MVTable *tab)
186
{
187
    int i, x, y;
188

    
189
    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
190
    /* mark all entries as not used */
191
    for(i=0;i<4096;i++)
192
        tab->table_mv_index[i] = tab->n;
193

    
194
    for(i=0;i<tab->n;i++) {
195
        x = tab->table_mvx[i];
196
        y = tab->table_mvy[i];
197
        tab->table_mv_index[(x << 6) | y] = i;
198
    }
199
}
200

    
201
void ff_msmpeg4_code012(PutBitContext *pb, int n)
202
{
203
    if (n == 0) {
204
        put_bits(pb, 1, 0);
205
    } else {
206
        put_bits(pb, 1, 1);
207
        put_bits(pb, 1, (n >= 2));
208
    }
209
}
210

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

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

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

    
252
av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
253
{
254
    static int init_done=0;
255
    int i;
256

    
257
    common_init(s);
258
    if(s->msmpeg4_version>=4){
259
        s->min_qcoeff= -255;
260
        s->max_qcoeff=  255;
261
    }
262

    
263
    if (!init_done) {
264
        /* init various encoding tables */
265
        init_done = 1;
266
        init_mv_table(&mv_tables[0]);
267
        init_mv_table(&mv_tables[1]);
268
        for(i=0;i<NB_RL_TABLES;i++)
269
            init_rl(&rl_table[i], static_rl_table_store[i]);
270

    
271
        for(i=0; i<NB_RL_TABLES; i++){
272
            int level;
273
            for(level=0; level<=MAX_LEVEL; level++){
274
                int run;
275
                for(run=0; run<=MAX_RUN; run++){
276
                    int last;
277
                    for(last=0; last<2; last++){
278
                        rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
279
                    }
280
                }
281
            }
282
        }
283
    }
284
}
285

    
286
static void find_best_tables(MpegEncContext * s)
287
{
288
    int i;
289
    int best       =-1, best_size       =9999999;
290
    int chroma_best=-1, best_chroma_size=9999999;
291

    
292
    for(i=0; i<3; i++){
293
        int level;
294
        int chroma_size=0;
295
        int size=0;
296

    
297
        if(i>0){// ;)
298
            size++;
299
            chroma_size++;
300
        }
301
        for(level=0; level<=MAX_LEVEL; level++){
302
            int run;
303
            for(run=0; run<=MAX_RUN; run++){
304
                int last;
305
                const int last_size= size + chroma_size;
306
                for(last=0; last<2; last++){
307
                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
308
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
309
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
310

    
311
                    if(s->pict_type==AV_PICTURE_TYPE_I){
312
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
313
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
314
                    }else{
315
                        size+=        intra_luma_count  *rl_length[i  ][level][run][last]
316
                                     +intra_chroma_count*rl_length[i+3][level][run][last]
317
                                     +inter_count       *rl_length[i+3][level][run][last];
318
                    }
319
                }
320
                if(last_size == size+chroma_size) break;
321
            }
322
        }
323
        if(size<best_size){
324
            best_size= size;
325
            best= i;
326
        }
327
        if(chroma_size<best_chroma_size){
328
            best_chroma_size= chroma_size;
329
            chroma_best= i;
330
        }
331
    }
332

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

    
336
    if(s->pict_type==AV_PICTURE_TYPE_P) chroma_best= best;
337

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

    
340
    s->rl_table_index       =        best;
341
    s->rl_chroma_table_index= chroma_best;
342

    
343
    if(s->pict_type != s->last_non_b_pict_type){
344
        s->rl_table_index= 2;
345
        if(s->pict_type==AV_PICTURE_TYPE_I)
346
            s->rl_chroma_table_index= 1;
347
        else
348
            s->rl_chroma_table_index= 2;
349
    }
350

    
351
}
352

    
353
/* write MSMPEG4 compatible frame header */
354
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
355
{
356
    find_best_tables(s);
357

    
358
    align_put_bits(&s->pb);
359
    put_bits(&s->pb, 2, s->pict_type - 1);
360

    
361
    put_bits(&s->pb, 5, s->qscale);
362
    if(s->msmpeg4_version<=2){
363
        s->rl_table_index = 2;
364
        s->rl_chroma_table_index = 2;
365
    }
366

    
367
    s->dc_table_index = 1;
368
    s->mv_table_index = 1; /* only if P frame */
369
    s->use_skip_mb_code = 1; /* only if P frame */
370
    s->per_mb_rl_table = 0;
371
    if(s->msmpeg4_version==4)
372
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==AV_PICTURE_TYPE_P);
373
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
374

    
375
    if (s->pict_type == AV_PICTURE_TYPE_I) {
376
        s->slice_height= s->mb_height/1;
377
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
378

    
379
        if(s->msmpeg4_version==4){
380
            msmpeg4_encode_ext_header(s);
381
            if(s->bit_rate>MBAC_BITRATE)
382
                put_bits(&s->pb, 1, s->per_mb_rl_table);
383
        }
384

    
385
        if(s->msmpeg4_version>2){
386
            if(!s->per_mb_rl_table){
387
                ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
388
                ff_msmpeg4_code012(&s->pb, s->rl_table_index);
389
            }
390

    
391
            put_bits(&s->pb, 1, s->dc_table_index);
392
        }
393
    } else {
394
        put_bits(&s->pb, 1, s->use_skip_mb_code);
395

    
396
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
397
            put_bits(&s->pb, 1, s->per_mb_rl_table);
398

    
399
        if(s->msmpeg4_version>2){
400
            if(!s->per_mb_rl_table)
401
                ff_msmpeg4_code012(&s->pb, s->rl_table_index);
402

    
403
            put_bits(&s->pb, 1, s->dc_table_index);
404

    
405
            put_bits(&s->pb, 1, s->mv_table_index);
406
        }
407
    }
408

    
409
    s->esc3_level_length= 0;
410
    s->esc3_run_length= 0;
411
}
412

    
413
void msmpeg4_encode_ext_header(MpegEncContext * s)
414
{
415
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
416

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

    
419
        if(s->msmpeg4_version>=3)
420
            put_bits(&s->pb, 1, s->flipflop_rounding);
421
        else
422
            assert(s->flipflop_rounding==0);
423
}
424

    
425
#endif //CONFIG_ENCODERS
426

    
427
/* predict coded block */
428
int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
429
{
430
    int xy, wrap, pred, a, b, c;
431

    
432
    xy = s->block_index[n];
433
    wrap = s->b8_stride;
434

    
435
    /* B C
436
     * A X
437
     */
438
    a = s->coded_block[xy - 1       ];
439
    b = s->coded_block[xy - 1 - wrap];
440
    c = s->coded_block[xy     - wrap];
441

    
442
    if (b == c) {
443
        pred = a;
444
    } else {
445
        pred = c;
446
    }
447

    
448
    /* store value */
449
    *coded_block_ptr = &s->coded_block[xy];
450

    
451
    return pred;
452
}
453

    
454
#if CONFIG_ENCODERS
455

    
456
void ff_msmpeg4_encode_motion(MpegEncContext * s,
457
                                  int mx, int my)
458
{
459
    int code;
460
    MVTable *mv;
461

    
462
    /* modulo encoding */
463
    /* WARNING : you cannot reach all the MVs even with the modulo
464
       encoding. This is a somewhat strange compromise they took !!!  */
465
    if (mx <= -64)
466
        mx += 64;
467
    else if (mx >= 64)
468
        mx -= 64;
469
    if (my <= -64)
470
        my += 64;
471
    else if (my >= 64)
472
        my -= 64;
473

    
474
    mx += 32;
475
    my += 32;
476
#if 0
477
    if ((unsigned)mx >= 64 ||
478
        (unsigned)my >= 64)
479
        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
480
#endif
481
    mv = &mv_tables[s->mv_table_index];
482

    
483
    code = mv->table_mv_index[(mx << 6) | my];
484
    put_bits(&s->pb,
485
             mv->table_mv_bits[code],
486
             mv->table_mv_code[code]);
487
    if (code == mv->n) {
488
        /* escape : code literally */
489
        put_bits(&s->pb, 6, mx);
490
        put_bits(&s->pb, 6, my);
491
    }
492
}
493

    
494
void ff_msmpeg4_handle_slices(MpegEncContext *s){
495
    if (s->mb_x == 0) {
496
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
497
            if(s->msmpeg4_version < 4){
498
                ff_mpeg4_clean_buffers(s);
499
            }
500
            s->first_slice_line = 1;
501
        } else {
502
            s->first_slice_line = 0;
503
        }
504
    }
505
}
506

    
507
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
508
{
509
    int range, bit_size, sign, code, bits;
510

    
511
    if (val == 0) {
512
        /* zero vector */
513
        code = 0;
514
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
515
    } else {
516
        bit_size = s->f_code - 1;
517
        range = 1 << bit_size;
518
        if (val <= -64)
519
            val += 64;
520
        else if (val >= 64)
521
            val -= 64;
522

    
523
        if (val >= 0) {
524
            sign = 0;
525
        } else {
526
            val = -val;
527
            sign = 1;
528
        }
529
        val--;
530
        code = (val >> bit_size) + 1;
531
        bits = val & (range - 1);
532

    
533
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
534
        if (bit_size > 0) {
535
            put_bits(&s->pb, bit_size, bits);
536
        }
537
    }
538
}
539

    
540
void msmpeg4_encode_mb(MpegEncContext * s,
541
                       DCTELEM block[6][64],
542
                       int motion_x, int motion_y)
543
{
544
    int cbp, coded_cbp, i;
545
    int pred_x, pred_y;
546
    uint8_t *coded_block;
547

    
548
    ff_msmpeg4_handle_slices(s);
549

    
550
    if (!s->mb_intra) {
551
        /* compute cbp */
552
        cbp = 0;
553
        for (i = 0; i < 6; i++) {
554
            if (s->block_last_index[i] >= 0)
555
                cbp |= 1 << (5 - i);
556
        }
557
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
558
            /* skip macroblock */
559
            put_bits(&s->pb, 1, 1);
560
            s->last_bits++;
561
            s->misc_bits++;
562
            s->skip_count++;
563

    
564
            return;
565
        }
566
        if (s->use_skip_mb_code)
567
            put_bits(&s->pb, 1, 0);     /* mb coded */
568

    
569
        if(s->msmpeg4_version<=2){
570
            put_bits(&s->pb,
571
                     v2_mb_type[cbp&3][1],
572
                     v2_mb_type[cbp&3][0]);
573
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
574
            else             coded_cbp= cbp;
575

    
576
            put_bits(&s->pb,
577
                     ff_h263_cbpy_tab[coded_cbp>>2][1],
578
                     ff_h263_cbpy_tab[coded_cbp>>2][0]);
579

    
580
            s->misc_bits += get_bits_diff(s);
581

    
582
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
583
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
584
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
585
        }else{
586
            put_bits(&s->pb,
587
                     table_mb_non_intra[cbp + 64][1],
588
                     table_mb_non_intra[cbp + 64][0]);
589

    
590
            s->misc_bits += get_bits_diff(s);
591

    
592
            /* motion vector */
593
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
594
            ff_msmpeg4_encode_motion(s, motion_x - pred_x,
595
                                  motion_y - pred_y);
596
        }
597

    
598
        s->mv_bits += get_bits_diff(s);
599

    
600
        for (i = 0; i < 6; i++) {
601
            ff_msmpeg4_encode_block(s, block[i], i);
602
        }
603
        s->p_tex_bits += get_bits_diff(s);
604
    } else {
605
        /* compute cbp */
606
        cbp = 0;
607
        coded_cbp = 0;
608
        for (i = 0; i < 6; i++) {
609
            int val, pred;
610
            val = (s->block_last_index[i] >= 1);
611
            cbp |= val << (5 - i);
612
            if (i < 4) {
613
                /* predict value for close blocks only for luma */
614
                pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
615
                *coded_block = val;
616
                val = val ^ pred;
617
            }
618
            coded_cbp |= val << (5 - i);
619
        }
620

    
621
        if(s->msmpeg4_version<=2){
622
            if (s->pict_type == AV_PICTURE_TYPE_I) {
623
                put_bits(&s->pb,
624
                         v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
625
            } else {
626
                if (s->use_skip_mb_code)
627
                    put_bits(&s->pb, 1, 0);     /* mb coded */
628
                put_bits(&s->pb,
629
                         v2_mb_type[(cbp&3) + 4][1],
630
                         v2_mb_type[(cbp&3) + 4][0]);
631
            }
632
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
633
            put_bits(&s->pb,
634
                     ff_h263_cbpy_tab[cbp>>2][1],
635
                     ff_h263_cbpy_tab[cbp>>2][0]);
636
        }else{
637
            if (s->pict_type == AV_PICTURE_TYPE_I) {
638
                put_bits(&s->pb,
639
                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
640
            } else {
641
                if (s->use_skip_mb_code)
642
                    put_bits(&s->pb, 1, 0);     /* mb coded */
643
                put_bits(&s->pb,
644
                         table_mb_non_intra[cbp][1],
645
                         table_mb_non_intra[cbp][0]);
646
            }
647
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
648
            if(s->inter_intra_pred){
649
                s->h263_aic_dir=0;
650
                put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
651
            }
652
        }
653
        s->misc_bits += get_bits_diff(s);
654

    
655
        for (i = 0; i < 6; i++) {
656
            ff_msmpeg4_encode_block(s, block[i], i);
657
        }
658
        s->i_tex_bits += get_bits_diff(s);
659
        s->i_count++;
660
    }
661
}
662

    
663
#endif //CONFIG_ENCODERS
664

    
665
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
666
                                    int32_t **dc_val_ptr)
667
{
668
    int i;
669

    
670
    if (n < 4) {
671
        i= 0;
672
    } else {
673
        i= n-3;
674
    }
675

    
676
    *dc_val_ptr= &s->last_dc[i];
677
    return s->last_dc[i];
678
}
679

    
680
static int get_dc(uint8_t *src, int stride, int scale)
681
{
682
    int y;
683
    int sum=0;
684
    for(y=0; y<8; y++){
685
        int x;
686
        for(x=0; x<8; x++){
687
            sum+=src[x + y*stride];
688
        }
689
    }
690
    return FASTDIV((sum + (scale>>1)), scale);
691
}
692

    
693
/* dir = 0: left, dir = 1: top prediction */
694
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
695
                             int16_t **dc_val_ptr, int *dir_ptr)
696
{
697
    int a, b, c, wrap, pred, scale;
698
    int16_t *dc_val;
699

    
700
    /* find prediction */
701
    if (n < 4) {
702
        scale = s->y_dc_scale;
703
    } else {
704
        scale = s->c_dc_scale;
705
    }
706

    
707
    wrap = s->block_wrap[n];
708
    dc_val= s->dc_val[0] + s->block_index[n];
709

    
710
    /* B C
711
     * A X
712
     */
713
    a = dc_val[ - 1];
714
    b = dc_val[ - 1 - wrap];
715
    c = dc_val[ - wrap];
716

    
717
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
718
        b=c=1024;
719
    }
720

    
721
    /* XXX: the following solution consumes divisions, but it does not
722
       necessitate to modify mpegvideo.c. The problem comes from the
723
       fact they decided to store the quantized DC (which would lead
724
       to problems if Q could vary !) */
725
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
726
    __asm__ volatile(
727
        "movl %3, %%eax         \n\t"
728
        "shrl $1, %%eax         \n\t"
729
        "addl %%eax, %2         \n\t"
730
        "addl %%eax, %1         \n\t"
731
        "addl %0, %%eax         \n\t"
732
        "mull %4                \n\t"
733
        "movl %%edx, %0         \n\t"
734
        "movl %1, %%eax         \n\t"
735
        "mull %4                \n\t"
736
        "movl %%edx, %1         \n\t"
737
        "movl %2, %%eax         \n\t"
738
        "mull %4                \n\t"
739
        "movl %%edx, %2         \n\t"
740
        : "+b" (a), "+c" (b), "+D" (c)
741
        : "g" (scale), "S" (ff_inverse[scale])
742
        : "%eax", "%edx"
743
    );
744
#else
745
    /* #elif ARCH_ALPHA */
746
    /* Divisions are extremely costly on Alpha; optimize the most
747
       common case. But they are costly everywhere...
748
     */
749
    if (scale == 8) {
750
        a = (a + (8 >> 1)) / 8;
751
        b = (b + (8 >> 1)) / 8;
752
        c = (c + (8 >> 1)) / 8;
753
    } else {
754
        a = FASTDIV((a + (scale >> 1)), scale);
755
        b = FASTDIV((b + (scale >> 1)), scale);
756
        c = FASTDIV((c + (scale >> 1)), scale);
757
    }
758
#endif
759
    /* XXX: WARNING: they did not choose the same test as MPEG4. This
760
       is very important ! */
761
    if(s->msmpeg4_version>3){
762
        if(s->inter_intra_pred){
763
            uint8_t *dest;
764
            int wrap;
765

    
766
            if(n==1){
767
                pred=a;
768
                *dir_ptr = 0;
769
            }else if(n==2){
770
                pred=c;
771
                *dir_ptr = 1;
772
            }else if(n==3){
773
                if (abs(a - b) < abs(b - c)) {
774
                    pred = c;
775
                    *dir_ptr = 1;
776
                } else {
777
                    pred = a;
778
                    *dir_ptr = 0;
779
                }
780
            }else{
781
                if(n<4){
782
                    wrap= s->linesize;
783
                    dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
784
                }else{
785
                    wrap= s->uvlinesize;
786
                    dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
787
                }
788
                if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
789
                else           a= get_dc(dest-8, wrap, scale*8);
790
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
791
                else           c= get_dc(dest-8*wrap, wrap, scale*8);
792

    
793
                if (s->h263_aic_dir==0) {
794
                    pred= a;
795
                    *dir_ptr = 0;
796
                }else if (s->h263_aic_dir==1) {
797
                    if(n==0){
798
                        pred= c;
799
                        *dir_ptr = 1;
800
                    }else{
801
                        pred= a;
802
                        *dir_ptr = 0;
803
                    }
804
                }else if (s->h263_aic_dir==2) {
805
                    if(n==0){
806
                        pred= a;
807
                        *dir_ptr = 0;
808
                    }else{
809
                        pred= c;
810
                        *dir_ptr = 1;
811
                    }
812
                } else {
813
                    pred= c;
814
                    *dir_ptr = 1;
815
                }
816
            }
817
        }else{
818
            if (abs(a - b) < abs(b - c)) {
819
                pred = c;
820
                *dir_ptr = 1;
821
            } else {
822
                pred = a;
823
                *dir_ptr = 0;
824
            }
825
        }
826
    }else{
827
        if (abs(a - b) <= abs(b - c)) {
828
            pred = c;
829
            *dir_ptr = 1;
830
        } else {
831
            pred = a;
832
            *dir_ptr = 0;
833
        }
834
    }
835

    
836
    /* update predictor */
837
    *dc_val_ptr = &dc_val[0];
838
    return pred;
839
}
840

    
841
#define DC_MAX 119
842

    
843
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
844
{
845
    int sign, code;
846
    int pred, extquant;
847
    int extrabits = 0;
848

    
849
    if(s->msmpeg4_version==1){
850
        int32_t *dc_val;
851
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
852

    
853
        /* update predictor */
854
        *dc_val= level;
855
    }else{
856
        int16_t *dc_val;
857
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
858

    
859
        /* update predictor */
860
        if (n < 4) {
861
            *dc_val = level * s->y_dc_scale;
862
        } else {
863
            *dc_val = level * s->c_dc_scale;
864
        }
865
    }
866

    
867
    /* do the prediction */
868
    level -= pred;
869

    
870
    if(s->msmpeg4_version<=2){
871
        if (n < 4) {
872
            put_bits(&s->pb,
873
                     v2_dc_lum_table[level+256][1],
874
                     v2_dc_lum_table[level+256][0]);
875
        }else{
876
            put_bits(&s->pb,
877
                     v2_dc_chroma_table[level+256][1],
878
                     v2_dc_chroma_table[level+256][0]);
879
        }
880
    }else{
881
        sign = 0;
882
        if (level < 0) {
883
            level = -level;
884
            sign = 1;
885
        }
886
        code = level;
887
        if (code > DC_MAX)
888
            code = DC_MAX;
889
        else if( s->msmpeg4_version>=6 ) {
890
            if( s->qscale == 1 ) {
891
                extquant = (level + 3) & 0x3;
892
                code  = ((level+3)>>2);
893
            } else if( s->qscale == 2 ) {
894
                extquant = (level + 1) & 0x1;
895
                code  = ((level+1)>>1);
896
            }
897
        }
898

    
899
        if (s->dc_table_index == 0) {
900
            if (n < 4) {
901
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
902
            } else {
903
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
904
            }
905
        } else {
906
            if (n < 4) {
907
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
908
            } else {
909
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
910
            }
911
        }
912

    
913
        if(s->msmpeg4_version>=6 && s->qscale<=2)
914
            extrabits = 3 - s->qscale;
915

    
916
        if (code == DC_MAX)
917
            put_bits(&s->pb, 8 + extrabits, level);
918
        else if(extrabits > 0)//== VC1 && s->qscale<=2
919
            put_bits(&s->pb, extrabits, extquant);
920

    
921
        if (level != 0) {
922
            put_bits(&s->pb, 1, sign);
923
        }
924
    }
925
}
926

    
927
/* Encoding of a block. Very similar to MPEG4 except for a different
928
   escape coding (same as H263) and more vlc tables.
929
 */
930
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
931
{
932
    int level, run, last, i, j, last_index;
933
    int last_non_zero, sign, slevel;
934
    int code, run_diff, dc_pred_dir;
935
    const RLTable *rl;
936
    const uint8_t *scantable;
937

    
938
    if (s->mb_intra) {
939
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
940
        i = 1;
941
        if (n < 4) {
942
            rl = &rl_table[s->rl_table_index];
943
        } else {
944
            rl = &rl_table[3 + s->rl_chroma_table_index];
945
        }
946
        run_diff = s->msmpeg4_version>=4;
947
        scantable= s->intra_scantable.permutated;
948
    } else {
949
        i = 0;
950
        rl = &rl_table[3 + s->rl_table_index];
951
        if(s->msmpeg4_version<=2)
952
            run_diff = 0;
953
        else
954
            run_diff = 1;
955
        scantable= s->inter_scantable.permutated;
956
    }
957

    
958
    /* recalculate block_last_index for M$ wmv1 */
959
    if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
960
        for(last_index=63; last_index>=0; last_index--){
961
            if(block[scantable[last_index]]) break;
962
        }
963
        s->block_last_index[n]= last_index;
964
    }else
965
        last_index = s->block_last_index[n];
966
    /* AC coefs */
967
    last_non_zero = i - 1;
968
    for (; i <= last_index; i++) {
969
        j = scantable[i];
970
        level = block[j];
971
        if (level) {
972
            run = i - last_non_zero - 1;
973
            last = (i == last_index);
974
            sign = 0;
975
            slevel = level;
976
            if (level < 0) {
977
                sign = 1;
978
                level = -level;
979
            }
980

    
981
            if(level<=MAX_LEVEL && run<=MAX_RUN){
982
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
983
            }
984

    
985
            s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
986

    
987
            code = get_rl_index(rl, last, run, level);
988
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
989
            if (code == rl->n) {
990
                int level1, run1;
991

    
992
                level1 = level - rl->max_level[last][run];
993
                if (level1 < 1)
994
                    goto esc2;
995
                code = get_rl_index(rl, last, run, level1);
996
                if (code == rl->n) {
997
                esc2:
998
                    put_bits(&s->pb, 1, 0);
999
                    if (level > MAX_LEVEL)
1000
                        goto esc3;
1001
                    run1 = run - rl->max_run[last][level] - run_diff;
1002
                    if (run1 < 0)
1003
                        goto esc3;
1004
                    code = get_rl_index(rl, last, run1+1, level);
1005
                    if (s->msmpeg4_version == 4 && code == rl->n)
1006
                        goto esc3;
1007
                    code = get_rl_index(rl, last, run1, level);
1008
                    if (code == rl->n) {
1009
                    esc3:
1010
                        /* third escape */
1011
                        put_bits(&s->pb, 1, 0);
1012
                        put_bits(&s->pb, 1, last);
1013
                        if(s->msmpeg4_version>=4){
1014
                            if(s->esc3_level_length==0){
1015
                                s->esc3_level_length=8;
1016
                                s->esc3_run_length= 6;
1017
                                //ESCLVLSZ + ESCRUNSZ
1018
                                if(s->qscale<8)
1019
                                    put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
1020
                                else
1021
                                    put_bits(&s->pb, 8, 3);
1022
                            }
1023
                            put_bits(&s->pb, s->esc3_run_length, run);
1024
                            put_bits(&s->pb, 1, sign);
1025
                            put_bits(&s->pb, s->esc3_level_length, level);
1026
                        }else{
1027
                            put_bits(&s->pb, 6, run);
1028
                            put_sbits(&s->pb, 8, slevel);
1029
                        }
1030
                    } else {
1031
                        /* second escape */
1032
                        put_bits(&s->pb, 1, 1);
1033
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1034
                        put_bits(&s->pb, 1, sign);
1035
                    }
1036
                } else {
1037
                    /* first escape */
1038
                    put_bits(&s->pb, 1, 1);
1039
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1040
                    put_bits(&s->pb, 1, sign);
1041
                }
1042
            } else {
1043
                put_bits(&s->pb, 1, sign);
1044
            }
1045
            last_non_zero = i;
1046
        }
1047
    }
1048
}
1049

    
1050
/****************************************/
1051
/* decoding stuff */
1052

    
1053
VLC ff_mb_non_intra_vlc[4];
1054
static VLC v2_dc_lum_vlc;
1055
static VLC v2_dc_chroma_vlc;
1056
static VLC v2_intra_cbpc_vlc;
1057
static VLC v2_mb_type_vlc;
1058
static VLC v2_mv_vlc;
1059
VLC ff_inter_intra_vlc;
1060

    
1061
/* This is identical to h263 except that its range is multiplied by 2. */
1062
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1063
{
1064
    int code, val, sign, shift;
1065

    
1066
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1067
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1068
    if (code < 0)
1069
        return 0xffff;
1070

    
1071
    if (code == 0)
1072
        return pred;
1073
    sign = get_bits1(&s->gb);
1074
    shift = f_code - 1;
1075
    val = code;
1076
    if (shift) {
1077
        val = (val - 1) << shift;
1078
        val |= get_bits(&s->gb, shift);
1079
        val++;
1080
    }
1081
    if (sign)
1082
        val = -val;
1083

    
1084
    val += pred;
1085
    if (val <= -64)
1086
        val += 64;
1087
    else if (val >= 64)
1088
        val -= 64;
1089

    
1090
    return val;
1091
}
1092

    
1093
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1094
{
1095
    int cbp, code, i;
1096

    
1097
    if (s->pict_type == AV_PICTURE_TYPE_P) {
1098
        if (s->use_skip_mb_code) {
1099
            if (get_bits1(&s->gb)) {
1100
                /* skip mb */
1101
                s->mb_intra = 0;
1102
                for(i=0;i<6;i++)
1103
                    s->block_last_index[i] = -1;
1104
                s->mv_dir = MV_DIR_FORWARD;
1105
                s->mv_type = MV_TYPE_16X16;
1106
                s->mv[0][0][0] = 0;
1107
                s->mv[0][0][1] = 0;
1108
                s->mb_skipped = 1;
1109
                return 0;
1110
            }
1111
        }
1112

    
1113
        if(s->msmpeg4_version==2)
1114
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1115
        else
1116
            code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
1117
        if(code<0 || code>7){
1118
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1119
            return -1;
1120
        }
1121

    
1122
        s->mb_intra = code >>2;
1123

    
1124
        cbp = code & 0x3;
1125
    } else {
1126
        s->mb_intra = 1;
1127
        if(s->msmpeg4_version==2)
1128
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1129
        else
1130
            cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
1131
        if(cbp<0 || cbp>3){
1132
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1133
            return -1;
1134
        }
1135
    }
1136

    
1137
    if (!s->mb_intra) {
1138
        int mx, my, cbpy;
1139

    
1140
        cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1141
        if(cbpy<0){
1142
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1143
            return -1;
1144
        }
1145

    
1146
        cbp|= cbpy<<2;
1147
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1148

    
1149
        h263_pred_motion(s, 0, 0, &mx, &my);
1150
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1151
        my= msmpeg4v2_decode_motion(s, my, 1);
1152

    
1153
        s->mv_dir = MV_DIR_FORWARD;
1154
        s->mv_type = MV_TYPE_16X16;
1155
        s->mv[0][0][0] = mx;
1156
        s->mv[0][0][1] = my;
1157
    } else {
1158
        if(s->msmpeg4_version==2){
1159
            s->ac_pred = get_bits1(&s->gb);
1160
            cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1161
        } else{
1162
            s->ac_pred = 0;
1163
            cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1164
            if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
1165
        }
1166
    }
1167

    
1168
    s->dsp.clear_blocks(s->block[0]);
1169
    for (i = 0; i < 6; i++) {
1170
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1171
        {
1172
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1173
             return -1;
1174
        }
1175
    }
1176
    return 0;
1177
}
1178

    
1179
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1180
{
1181
    int cbp, code, i;
1182
    uint8_t *coded_val;
1183
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1184

    
1185
    if (s->pict_type == AV_PICTURE_TYPE_P) {
1186
        if (s->use_skip_mb_code) {
1187
            if (get_bits1(&s->gb)) {
1188
                /* skip mb */
1189
                s->mb_intra = 0;
1190
                for(i=0;i<6;i++)
1191
                    s->block_last_index[i] = -1;
1192
                s->mv_dir = MV_DIR_FORWARD;
1193
                s->mv_type = MV_TYPE_16X16;
1194
                s->mv[0][0][0] = 0;
1195
                s->mv[0][0][1] = 0;
1196
                s->mb_skipped = 1;
1197
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1198

    
1199
                return 0;
1200
            }
1201
        }
1202

    
1203
        code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1204
        if (code < 0)
1205
            return -1;
1206
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1207
        s->mb_intra = (~code & 0x40) >> 6;
1208

    
1209
        cbp = code & 0x3f;
1210
    } else {
1211
        s->mb_intra = 1;
1212
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1213
        if (code < 0)
1214
            return -1;
1215
        /* predict coded block pattern */
1216
        cbp = 0;
1217
        for(i=0;i<6;i++) {
1218
            int val = ((code >> (5 - i)) & 1);
1219
            if (i < 4) {
1220
                int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1221
                val = val ^ pred;
1222
                *coded_val = val;
1223
            }
1224
            cbp |= val << (5 - i);
1225
        }
1226
    }
1227

    
1228
    if (!s->mb_intra) {
1229
        int mx, my;
1230
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1231
        if(s->per_mb_rl_table && cbp){
1232
            s->rl_table_index = decode012(&s->gb);
1233
            s->rl_chroma_table_index = s->rl_table_index;
1234
        }
1235
        h263_pred_motion(s, 0, 0, &mx, &my);
1236
        if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1237
            return -1;
1238
        s->mv_dir = MV_DIR_FORWARD;
1239
        s->mv_type = MV_TYPE_16X16;
1240
        s->mv[0][0][0] = mx;
1241
        s->mv[0][0][1] = my;
1242
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1243
    } else {
1244
//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));
1245
        s->ac_pred = get_bits1(&s->gb);
1246
        *mb_type_ptr = MB_TYPE_INTRA;
1247
        if(s->inter_intra_pred){
1248
            s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1249
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1250
        }
1251
        if(s->per_mb_rl_table && cbp){
1252
            s->rl_table_index = decode012(&s->gb);
1253
            s->rl_chroma_table_index = s->rl_table_index;
1254
        }
1255
    }
1256

    
1257
    s->dsp.clear_blocks(s->block[0]);
1258
    for (i = 0; i < 6; i++) {
1259
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1260
        {
1261
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1262
            return -1;
1263
        }
1264
    }
1265

    
1266
    return 0;
1267
}
1268

    
1269
/* init all vlc decoding tables */
1270
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1271
{
1272
    MpegEncContext *s = avctx->priv_data;
1273
    static int done = 0;
1274
    int i;
1275
    MVTable *mv;
1276

    
1277
    if (ff_h263_decode_init(avctx) < 0)
1278
        return -1;
1279

    
1280
    common_init(s);
1281

    
1282
    if (!done) {
1283
        done = 1;
1284

    
1285
        for(i=0;i<NB_RL_TABLES;i++) {
1286
            init_rl(&rl_table[i], static_rl_table_store[i]);
1287
        }
1288
        INIT_VLC_RL(rl_table[0], 642);
1289
        INIT_VLC_RL(rl_table[1], 1104);
1290
        INIT_VLC_RL(rl_table[2], 554);
1291
        INIT_VLC_RL(rl_table[3], 940);
1292
        INIT_VLC_RL(rl_table[4], 962);
1293
        INIT_VLC_RL(rl_table[5], 554);
1294

    
1295
        mv = &mv_tables[0];
1296
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1297
                    mv->table_mv_bits, 1, 1,
1298
                    mv->table_mv_code, 2, 2, 3714);
1299
        mv = &mv_tables[1];
1300
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1301
                    mv->table_mv_bits, 1, 1,
1302
                    mv->table_mv_code, 2, 2, 2694);
1303

    
1304
        INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1305
                 &ff_table0_dc_lum[0][1], 8, 4,
1306
                 &ff_table0_dc_lum[0][0], 8, 4, 1158);
1307
        INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1308
                 &ff_table0_dc_chroma[0][1], 8, 4,
1309
                 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
1310
        INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1311
                 &ff_table1_dc_lum[0][1], 8, 4,
1312
                 &ff_table1_dc_lum[0][0], 8, 4, 1476);
1313
        INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1314
                 &ff_table1_dc_chroma[0][1], 8, 4,
1315
                 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
1316

    
1317
        INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1318
                 &v2_dc_lum_table[0][1], 8, 4,
1319
                 &v2_dc_lum_table[0][0], 8, 4, 1472);
1320
        INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1321
                 &v2_dc_chroma_table[0][1], 8, 4,
1322
                 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1323

    
1324
        INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1325
                 &v2_intra_cbpc[0][1], 2, 1,
1326
                 &v2_intra_cbpc[0][0], 2, 1, 8);
1327
        INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1328
                 &v2_mb_type[0][1], 2, 1,
1329
                 &v2_mb_type[0][0], 2, 1, 128);
1330
        INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1331
                 &mvtab[0][1], 2, 1,
1332
                 &mvtab[0][0], 2, 1, 538);
1333

    
1334
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1335
                     &wmv2_inter_table[0][0][1], 8, 4,
1336
                     &wmv2_inter_table[0][0][0], 8, 4, 1636);
1337
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1338
                     &wmv2_inter_table[1][0][1], 8, 4,
1339
                     &wmv2_inter_table[1][0][0], 8, 4, 2648);
1340
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1341
                     &wmv2_inter_table[2][0][1], 8, 4,
1342
                     &wmv2_inter_table[2][0][0], 8, 4, 1532);
1343
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1344
                     &wmv2_inter_table[3][0][1], 8, 4,
1345
                     &wmv2_inter_table[3][0][0], 8, 4, 2488);
1346

    
1347
        INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1348
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
1349
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1350

    
1351
        INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1352
                 &table_inter_intra[0][1], 2, 1,
1353
                 &table_inter_intra[0][0], 2, 1, 8);
1354
    }
1355

    
1356
    switch(s->msmpeg4_version){
1357
    case 1:
1358
    case 2:
1359
        s->decode_mb= msmpeg4v12_decode_mb;
1360
        break;
1361
    case 3:
1362
    case 4:
1363
        s->decode_mb= msmpeg4v34_decode_mb;
1364
        break;
1365
    case 5:
1366
        if (CONFIG_WMV2_DECODER)
1367
            s->decode_mb= ff_wmv2_decode_mb;
1368
    case 6:
1369
        //FIXME + TODO VC1 decode mb
1370
        break;
1371
    }
1372

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

    
1375
    return 0;
1376
}
1377

    
1378
int msmpeg4_decode_picture_header(MpegEncContext * s)
1379
{
1380
    int code;
1381

    
1382
    if(s->msmpeg4_version==1){
1383
        int start_code = get_bits_long(&s->gb, 32);
1384
        if(start_code!=0x00000100){
1385
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1386
            return -1;
1387
        }
1388

    
1389
        skip_bits(&s->gb, 5); // frame number */
1390
    }
1391

    
1392
    s->pict_type = get_bits(&s->gb, 2) + 1;
1393
    if (s->pict_type != AV_PICTURE_TYPE_I &&
1394
        s->pict_type != AV_PICTURE_TYPE_P){
1395
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1396
        return -1;
1397
    }
1398
#if 0
1399
{
1400
    static int had_i=0;
1401
    if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
1402
    if(!had_i) return -1;
1403
}
1404
#endif
1405
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1406
    if(s->qscale==0){
1407
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1408
        return -1;
1409
    }
1410

    
1411
    if (s->pict_type == AV_PICTURE_TYPE_I) {
1412
        code = get_bits(&s->gb, 5);
1413
        if(s->msmpeg4_version==1){
1414
            if(code==0 || code>s->mb_height){
1415
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1416
                return -1;
1417
            }
1418

    
1419
            s->slice_height = code;
1420
        }else{
1421
            /* 0x17: one slice, 0x18: two slices, ... */
1422
            if (code < 0x17){
1423
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1424
                return -1;
1425
            }
1426

    
1427
            s->slice_height = s->mb_height / (code - 0x16);
1428
        }
1429

    
1430
        switch(s->msmpeg4_version){
1431
        case 1:
1432
        case 2:
1433
            s->rl_chroma_table_index = 2;
1434
            s->rl_table_index = 2;
1435

    
1436
            s->dc_table_index = 0; //not used
1437
            break;
1438
        case 3:
1439
            s->rl_chroma_table_index = decode012(&s->gb);
1440
            s->rl_table_index = decode012(&s->gb);
1441

    
1442
            s->dc_table_index = get_bits1(&s->gb);
1443
            break;
1444
        case 4:
1445
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1446

    
1447
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1448
            else                           s->per_mb_rl_table= 0;
1449

    
1450
            if(!s->per_mb_rl_table){
1451
                s->rl_chroma_table_index = decode012(&s->gb);
1452
                s->rl_table_index = decode012(&s->gb);
1453
            }
1454

    
1455
            s->dc_table_index = get_bits1(&s->gb);
1456
            s->inter_intra_pred= 0;
1457
            break;
1458
        }
1459
        s->no_rounding = 1;
1460
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1461
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1462
                s->qscale,
1463
                s->rl_chroma_table_index,
1464
                s->rl_table_index,
1465
                s->dc_table_index,
1466
                s->per_mb_rl_table,
1467
                s->slice_height);
1468
    } else {
1469
        switch(s->msmpeg4_version){
1470
        case 1:
1471
        case 2:
1472
            if(s->msmpeg4_version==1)
1473
                s->use_skip_mb_code = 1;
1474
            else
1475
                s->use_skip_mb_code = get_bits1(&s->gb);
1476
            s->rl_table_index = 2;
1477
            s->rl_chroma_table_index = s->rl_table_index;
1478
            s->dc_table_index = 0; //not used
1479
            s->mv_table_index = 0;
1480
            break;
1481
        case 3:
1482
            s->use_skip_mb_code = get_bits1(&s->gb);
1483
            s->rl_table_index = decode012(&s->gb);
1484
            s->rl_chroma_table_index = s->rl_table_index;
1485

    
1486
            s->dc_table_index = get_bits1(&s->gb);
1487

    
1488
            s->mv_table_index = get_bits1(&s->gb);
1489
            break;
1490
        case 4:
1491
            s->use_skip_mb_code = get_bits1(&s->gb);
1492

    
1493
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1494
            else                           s->per_mb_rl_table= 0;
1495

    
1496
            if(!s->per_mb_rl_table){
1497
                s->rl_table_index = decode012(&s->gb);
1498
                s->rl_chroma_table_index = s->rl_table_index;
1499
            }
1500

    
1501
            s->dc_table_index = get_bits1(&s->gb);
1502

    
1503
            s->mv_table_index = get_bits1(&s->gb);
1504
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1505
            break;
1506
        }
1507

    
1508
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1509
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1510
                s->use_skip_mb_code,
1511
                s->rl_table_index,
1512
                s->rl_chroma_table_index,
1513
                s->dc_table_index,
1514
                s->mv_table_index,
1515
                s->per_mb_rl_table,
1516
                s->qscale);
1517

    
1518
        if(s->flipflop_rounding){
1519
            s->no_rounding ^= 1;
1520
        }else{
1521
            s->no_rounding = 0;
1522
        }
1523
    }
1524
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1525

    
1526
    s->esc3_level_length= 0;
1527
    s->esc3_run_length= 0;
1528

    
1529
    return 0;
1530
}
1531

    
1532
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1533
{
1534
    int left= buf_size*8 - get_bits_count(&s->gb);
1535
    int length= s->msmpeg4_version>=3 ? 17 : 16;
1536
    /* the alt_bitstream reader could read over the end so we need to check it */
1537
    if(left>=length && left<length+8)
1538
    {
1539
        int fps;
1540

    
1541
        fps= get_bits(&s->gb, 5);
1542
        s->bit_rate= get_bits(&s->gb, 11)*1024;
1543
        if(s->msmpeg4_version>=3)
1544
            s->flipflop_rounding= get_bits1(&s->gb);
1545
        else
1546
            s->flipflop_rounding= 0;
1547

    
1548
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1549
    }
1550
    else if(left<length+8)
1551
    {
1552
        s->flipflop_rounding= 0;
1553
        if(s->msmpeg4_version != 2)
1554
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1555
    }
1556
    else
1557
    {
1558
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1559
    }
1560

    
1561
    return 0;
1562
}
1563

    
1564
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1565
{
1566
    int level, pred;
1567

    
1568
    if(s->msmpeg4_version<=2){
1569
        if (n < 4) {
1570
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1571
        } else {
1572
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1573
        }
1574
        if (level < 0)
1575
            return -1;
1576
        level-=256;
1577
    }else{  //FIXME optimize use unified tables & index
1578
        if (n < 4) {
1579
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1580
        } else {
1581
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1582
        }
1583
        if (level < 0){
1584
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1585
            return -1;
1586
        }
1587

    
1588
        if (level == DC_MAX) {
1589
            level = get_bits(&s->gb, 8);
1590
            if (get_bits1(&s->gb))
1591
                level = -level;
1592
        } else if (level != 0) {
1593
            if (get_bits1(&s->gb))
1594
                level = -level;
1595
        }
1596
    }
1597

    
1598
    if(s->msmpeg4_version==1){
1599
        int32_t *dc_val;
1600
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1601
        level += pred;
1602

    
1603
        /* update predictor */
1604
        *dc_val= level;
1605
    }else{
1606
        int16_t *dc_val;
1607
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1608
        level += pred;
1609

    
1610
        /* update predictor */
1611
        if (n < 4) {
1612
            *dc_val = level * s->y_dc_scale;
1613
        } else {
1614
            *dc_val = level * s->c_dc_scale;
1615
        }
1616
    }
1617

    
1618
    return level;
1619
}
1620

    
1621
//#define ERROR_DETAILS
1622
int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1623
                              int n, int coded, const uint8_t *scan_table)
1624
{
1625
    int level, i, last, run, run_diff;
1626
    int av_uninit(dc_pred_dir);
1627
    RLTable *rl;
1628
    RL_VLC_ELEM *rl_vlc;
1629
    int qmul, qadd;
1630

    
1631
    if (s->mb_intra) {
1632
        qmul=1;
1633
        qadd=0;
1634

    
1635
        /* DC coef */
1636
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1637

    
1638
        if (level < 0){
1639
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1640
            if(s->inter_intra_pred) level=0;
1641
            else                    return -1;
1642
        }
1643
        if (n < 4) {
1644
            rl = &rl_table[s->rl_table_index];
1645
            if(level > 256*s->y_dc_scale){
1646
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1647
                if(!s->inter_intra_pred) return -1;
1648
            }
1649
        } else {
1650
            rl = &rl_table[3 + s->rl_chroma_table_index];
1651
            if(level > 256*s->c_dc_scale){
1652
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1653
                if(!s->inter_intra_pred) return -1;
1654
            }
1655
        }
1656
        block[0] = level;
1657

    
1658
        run_diff = s->msmpeg4_version >= 4;
1659
        i = 0;
1660
        if (!coded) {
1661
            goto not_coded;
1662
        }
1663
        if (s->ac_pred) {
1664
            if (dc_pred_dir == 0)
1665
                scan_table = s->intra_v_scantable.permutated; /* left */
1666
            else
1667
                scan_table = s->intra_h_scantable.permutated; /* top */
1668
        } else {
1669
            scan_table = s->intra_scantable.permutated;
1670
        }
1671
        rl_vlc= rl->rl_vlc[0];
1672
    } else {
1673
        qmul = s->qscale << 1;
1674
        qadd = (s->qscale - 1) | 1;
1675
        i = -1;
1676
        rl = &rl_table[3 + s->rl_table_index];
1677

    
1678
        if(s->msmpeg4_version==2)
1679
            run_diff = 0;
1680
        else
1681
            run_diff = 1;
1682

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

    
1730
                            s->esc3_level_length= ll;
1731
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1732
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1733
                            UPDATE_CACHE(re, &s->gb);
1734
                        }
1735
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1736
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
1737

    
1738
                        sign=  SHOW_UBITS(re, &s->gb, 1);
1739
                        SKIP_BITS(re, &s->gb, 1);
1740

    
1741
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1742
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
1743
                        if(sign) level= -level;
1744
                    }
1745
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1746
#if 0 // waste of time / this will detect very few errors
1747
                    {
1748
                        const int abs_level= FFABS(level);
1749
                        const int run1= run - rl->max_run[last][abs_level] - run_diff;
1750
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1751
                            if(abs_level <= rl->max_level[last][run]){
1752
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1753
                                return DECODING_AC_LOST;
1754
                            }
1755
                            if(abs_level <= rl->max_level[last][run]*2){
1756
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1757
                                return DECODING_AC_LOST;
1758
                            }
1759
                            if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1760
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1761
                                return DECODING_AC_LOST;
1762
                            }
1763
                        }
1764
                    }
1765
#endif
1766
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1767
                    if (level>0) level= level * qmul + qadd;
1768
                    else         level= level * qmul - qadd;
1769
#if 0 // waste of time too :(
1770
                    if(level>2048 || level<-2048){
1771
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1772
                        return DECODING_AC_LOST;
1773
                    }
1774
#endif
1775
                    i+= run + 1;
1776
                    if(last) i+=192;
1777
#ifdef ERROR_DETAILS
1778
                if(run==66)
1779
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1780
                else if((i>62 && i<192) || i>192+63)
1781
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1782
#endif
1783
                } else {
1784
                    /* second escape */
1785
                    SKIP_BITS(re, &s->gb, 2);
1786
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1787
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1788
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1789
                    LAST_SKIP_BITS(re, &s->gb, 1);
1790
#ifdef ERROR_DETAILS
1791
                if(run==66)
1792
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1793
                else if((i>62 && i<192) || i>192+63)
1794
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1795
#endif
1796
                }
1797
            } else {
1798
                /* first escape */
1799
                SKIP_BITS(re, &s->gb, 1);
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= get_bits_left(&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
int ff_msmpeg4_decode_motion(MpegEncContext * s,
1858
                                 int *mx_ptr, int *my_ptr)
1859
{
1860
    MVTable *mv;
1861
    int code, mx, my;
1862

    
1863
    mv = &mv_tables[s->mv_table_index];
1864

    
1865
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1866
    if (code < 0){
1867
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1868
        return -1;
1869
    }
1870
    if (code == mv->n) {
1871
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1872
        mx = get_bits(&s->gb, 6);
1873
        my = get_bits(&s->gb, 6);
1874
    } else {
1875
        mx = mv->table_mvx[code];
1876
        my = mv->table_mvy[code];
1877
    }
1878

    
1879
    mx += *mx_ptr - 32;
1880
    my += *my_ptr - 32;
1881
    /* WARNING : they do not do exactly modulo encoding */
1882
    if (mx <= -64)
1883
        mx += 64;
1884
    else if (mx >= 64)
1885
        mx -= 64;
1886

    
1887
    if (my <= -64)
1888
        my += 64;
1889
    else if (my >= 64)
1890
        my -= 64;
1891
    *mx_ptr = mx;
1892
    *my_ptr = my;
1893
    return 0;
1894
}
1895

    
1896
AVCodec ff_msmpeg4v1_decoder = {
1897
    "msmpeg4v1",
1898
    AVMEDIA_TYPE_VIDEO,
1899
    CODEC_ID_MSMPEG4V1,
1900
    sizeof(MpegEncContext),
1901
    ff_msmpeg4_decode_init,
1902
    NULL,
1903
    ff_h263_decode_end,
1904
    ff_h263_decode_frame,
1905
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
1906
    .max_lowres= 3,
1907
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1908
    .pix_fmts= ff_pixfmt_list_420,
1909
};
1910

    
1911
AVCodec ff_msmpeg4v2_decoder = {
1912
    "msmpeg4v2",
1913
    AVMEDIA_TYPE_VIDEO,
1914
    CODEC_ID_MSMPEG4V2,
1915
    sizeof(MpegEncContext),
1916
    ff_msmpeg4_decode_init,
1917
    NULL,
1918
    ff_h263_decode_end,
1919
    ff_h263_decode_frame,
1920
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1921
    .max_lowres= 3,
1922
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1923
    .pix_fmts= ff_pixfmt_list_420,
1924
};
1925

    
1926
AVCodec ff_msmpeg4v3_decoder = {
1927
    "msmpeg4",
1928
    AVMEDIA_TYPE_VIDEO,
1929
    CODEC_ID_MSMPEG4V3,
1930
    sizeof(MpegEncContext),
1931
    ff_msmpeg4_decode_init,
1932
    NULL,
1933
    ff_h263_decode_end,
1934
    ff_h263_decode_frame,
1935
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1936
    .max_lowres= 3,
1937
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1938
    .pix_fmts= ff_pixfmt_list_420,
1939
};
1940

    
1941
AVCodec ff_wmv1_decoder = {
1942
    "wmv1",
1943
    AVMEDIA_TYPE_VIDEO,
1944
    CODEC_ID_WMV1,
1945
    sizeof(MpegEncContext),
1946
    ff_msmpeg4_decode_init,
1947
    NULL,
1948
    ff_h263_decode_end,
1949
    ff_h263_decode_frame,
1950
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1951
    .max_lowres= 3,
1952
    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1953
    .pix_fmts= ff_pixfmt_list_420,
1954
};