Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 72415b2a

History | View | Annotate | Download (61.3 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
#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==FF_I_TYPE){
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==FF_P_TYPE) 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==FF_I_TYPE)
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==FF_P_TYPE);
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 == FF_I_TYPE) {
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
#if 0
621
        if (coded_cbp)
622
            printf("cbp=%x %x\n", cbp, coded_cbp);
623
#endif
624

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

    
659
        for (i = 0; i < 6; i++) {
660
            ff_msmpeg4_encode_block(s, block[i], i);
661
        }
662
        s->i_tex_bits += get_bits_diff(s);
663
        s->i_count++;
664
    }
665
}
666

    
667
#endif //CONFIG_ENCODERS
668

    
669
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
670
                                    int32_t **dc_val_ptr)
671
{
672
    int i;
673

    
674
    if (n < 4) {
675
        i= 0;
676
    } else {
677
        i= n-3;
678
    }
679

    
680
    *dc_val_ptr= &s->last_dc[i];
681
    return s->last_dc[i];
682
}
683

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

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

    
704
    /* find prediction */
705
    if (n < 4) {
706
        scale = s->y_dc_scale;
707
    } else {
708
        scale = s->c_dc_scale;
709
    }
710

    
711
    wrap = s->block_wrap[n];
712
    dc_val= s->dc_val[0] + s->block_index[n];
713

    
714
    /* B C
715
     * A X
716
     */
717
    a = dc_val[ - 1];
718
    b = dc_val[ - 1 - wrap];
719
    c = dc_val[ - wrap];
720

    
721
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
722
        b=c=1024;
723
    }
724

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

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

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

    
840
    /* update predictor */
841
    *dc_val_ptr = &dc_val[0];
842
    return pred;
843
}
844

    
845
#define DC_MAX 119
846

    
847
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
848
{
849
    int sign, code;
850
    int pred, extquant;
851
    int extrabits = 0;
852

    
853
    if(s->msmpeg4_version==1){
854
        int32_t *dc_val;
855
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
856

    
857
        /* update predictor */
858
        *dc_val= level;
859
    }else{
860
        int16_t *dc_val;
861
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
862

    
863
        /* update predictor */
864
        if (n < 4) {
865
            *dc_val = level * s->y_dc_scale;
866
        } else {
867
            *dc_val = level * s->c_dc_scale;
868
        }
869
    }
870

    
871
    /* do the prediction */
872
    level -= pred;
873

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

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

    
917
        if(s->msmpeg4_version>=6 && s->qscale<=2)
918
            extrabits = 3 - s->qscale;
919

    
920
        if (code == DC_MAX)
921
            put_bits(&s->pb, 8 + extrabits, level);
922
        else if(extrabits > 0)//== VC1 && s->qscale<=2
923
            put_bits(&s->pb, extrabits, extquant);
924

    
925
        if (level != 0) {
926
            put_bits(&s->pb, 1, sign);
927
        }
928
    }
929
}
930

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

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

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

    
985
            if(level<=MAX_LEVEL && run<=MAX_RUN){
986
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
987
            }
988
#if 0
989
else
990
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
991
#endif
992
            code = get_rl_index(rl, last, run, level);
993
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
994
            if (code == rl->n) {
995
                int level1, run1;
996

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

    
1055
/****************************************/
1056
/* decoding stuff */
1057

    
1058
VLC ff_mb_non_intra_vlc[4];
1059
static VLC v2_dc_lum_vlc;
1060
static VLC v2_dc_chroma_vlc;
1061
static VLC v2_intra_cbpc_vlc;
1062
static VLC v2_mb_type_vlc;
1063
static VLC v2_mv_vlc;
1064
VLC ff_inter_intra_vlc;
1065

    
1066
/* This is identical to h263 except that its range is multiplied by 2. */
1067
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1068
{
1069
    int code, val, sign, shift;
1070

    
1071
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1072
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1073
    if (code < 0)
1074
        return 0xffff;
1075

    
1076
    if (code == 0)
1077
        return pred;
1078
    sign = get_bits1(&s->gb);
1079
    shift = f_code - 1;
1080
    val = code;
1081
    if (shift) {
1082
        val = (val - 1) << shift;
1083
        val |= get_bits(&s->gb, shift);
1084
        val++;
1085
    }
1086
    if (sign)
1087
        val = -val;
1088

    
1089
    val += pred;
1090
    if (val <= -64)
1091
        val += 64;
1092
    else if (val >= 64)
1093
        val -= 64;
1094

    
1095
    return val;
1096
}
1097

    
1098
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1099
{
1100
    int cbp, code, i;
1101

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

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

    
1127
        s->mb_intra = code >>2;
1128

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

    
1142
    if (!s->mb_intra) {
1143
        int mx, my, cbpy;
1144

    
1145
        cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1146
        if(cbpy<0){
1147
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1148
            return -1;
1149
        }
1150

    
1151
        cbp|= cbpy<<2;
1152
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1153

    
1154
        h263_pred_motion(s, 0, 0, &mx, &my);
1155
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1156
        my= msmpeg4v2_decode_motion(s, my, 1);
1157

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

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

    
1184
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1185
{
1186
    int cbp, code, i;
1187
    uint8_t *coded_val;
1188
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1189

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

    
1204
                return 0;
1205
            }
1206
        }
1207

    
1208
        code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1209
        if (code < 0)
1210
            return -1;
1211
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1212
        s->mb_intra = (~code & 0x40) >> 6;
1213

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

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

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

    
1271
    return 0;
1272
}
1273

    
1274
/* init all vlc decoding tables */
1275
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
1276
{
1277
    MpegEncContext *s = avctx->priv_data;
1278
    static int done = 0;
1279
    int i;
1280
    MVTable *mv;
1281

    
1282
    ff_h263_decode_init(avctx);
1283

    
1284
    common_init(s);
1285

    
1286
    if (!done) {
1287
        done = 1;
1288

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

    
1299
        mv = &mv_tables[0];
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, 3714);
1303
        mv = &mv_tables[1];
1304
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1305
                    mv->table_mv_bits, 1, 1,
1306
                    mv->table_mv_code, 2, 2, 2694);
1307

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

    
1321
        INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1322
                 &v2_dc_lum_table[0][1], 8, 4,
1323
                 &v2_dc_lum_table[0][0], 8, 4, 1472);
1324
        INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1325
                 &v2_dc_chroma_table[0][1], 8, 4,
1326
                 &v2_dc_chroma_table[0][0], 8, 4, 1506);
1327

    
1328
        INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1329
                 &v2_intra_cbpc[0][1], 2, 1,
1330
                 &v2_intra_cbpc[0][0], 2, 1, 8);
1331
        INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1332
                 &v2_mb_type[0][1], 2, 1,
1333
                 &v2_mb_type[0][0], 2, 1, 128);
1334
        INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1335
                 &mvtab[0][1], 2, 1,
1336
                 &mvtab[0][0], 2, 1, 538);
1337

    
1338
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
1339
                     &wmv2_inter_table[0][0][1], 8, 4,
1340
                     &wmv2_inter_table[0][0][0], 8, 4, 1636);
1341
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
1342
                     &wmv2_inter_table[1][0][1], 8, 4,
1343
                     &wmv2_inter_table[1][0][0], 8, 4, 2648);
1344
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
1345
                     &wmv2_inter_table[2][0][1], 8, 4,
1346
                     &wmv2_inter_table[2][0][0], 8, 4, 1532);
1347
        INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
1348
                     &wmv2_inter_table[3][0][1], 8, 4,
1349
                     &wmv2_inter_table[3][0][0], 8, 4, 2488);
1350

    
1351
        INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1352
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
1353
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
1354

    
1355
        INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1356
                 &table_inter_intra[0][1], 2, 1,
1357
                 &table_inter_intra[0][0], 2, 1, 8);
1358
    }
1359

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

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

    
1379
    return 0;
1380
}
1381

    
1382
int msmpeg4_decode_picture_header(MpegEncContext * s)
1383
{
1384
    int code;
1385

    
1386
#if 0
1387
{
1388
int i;
1389
for(i=0; i<s->gb.size_in_bits; i++)
1390
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1391
//    get_bits1(&s->gb);
1392
av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1393
return -1;
1394
}
1395
#endif
1396

    
1397
    if(s->msmpeg4_version==1){
1398
        int start_code;
1399
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1400
        if(start_code!=0x00000100){
1401
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1402
            return -1;
1403
        }
1404

    
1405
        skip_bits(&s->gb, 5); // frame number */
1406
    }
1407

    
1408
    s->pict_type = get_bits(&s->gb, 2) + 1;
1409
    if (s->pict_type != FF_I_TYPE &&
1410
        s->pict_type != FF_P_TYPE){
1411
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1412
        return -1;
1413
    }
1414
#if 0
1415
{
1416
    static int had_i=0;
1417
    if(s->pict_type == FF_I_TYPE) had_i=1;
1418
    if(!had_i) return -1;
1419
}
1420
#endif
1421
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1422
    if(s->qscale==0){
1423
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1424
        return -1;
1425
    }
1426

    
1427
    if (s->pict_type == FF_I_TYPE) {
1428
        code = get_bits(&s->gb, 5);
1429
        if(s->msmpeg4_version==1){
1430
            if(code==0 || code>s->mb_height){
1431
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1432
                return -1;
1433
            }
1434

    
1435
            s->slice_height = code;
1436
        }else{
1437
            /* 0x17: one slice, 0x18: two slices, ... */
1438
            if (code < 0x17){
1439
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1440
                return -1;
1441
            }
1442

    
1443
            s->slice_height = s->mb_height / (code - 0x16);
1444
        }
1445

    
1446
        switch(s->msmpeg4_version){
1447
        case 1:
1448
        case 2:
1449
            s->rl_chroma_table_index = 2;
1450
            s->rl_table_index = 2;
1451

    
1452
            s->dc_table_index = 0; //not used
1453
            break;
1454
        case 3:
1455
            s->rl_chroma_table_index = decode012(&s->gb);
1456
            s->rl_table_index = decode012(&s->gb);
1457

    
1458
            s->dc_table_index = get_bits1(&s->gb);
1459
            break;
1460
        case 4:
1461
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1462

    
1463
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1464
            else                           s->per_mb_rl_table= 0;
1465

    
1466
            if(!s->per_mb_rl_table){
1467
                s->rl_chroma_table_index = decode012(&s->gb);
1468
                s->rl_table_index = decode012(&s->gb);
1469
            }
1470

    
1471
            s->dc_table_index = get_bits1(&s->gb);
1472
            s->inter_intra_pred= 0;
1473
            break;
1474
        }
1475
        s->no_rounding = 1;
1476
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1477
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1478
                s->qscale,
1479
                s->rl_chroma_table_index,
1480
                s->rl_table_index,
1481
                s->dc_table_index,
1482
                s->per_mb_rl_table,
1483
                s->slice_height);
1484
    } else {
1485
        switch(s->msmpeg4_version){
1486
        case 1:
1487
        case 2:
1488
            if(s->msmpeg4_version==1)
1489
                s->use_skip_mb_code = 1;
1490
            else
1491
                s->use_skip_mb_code = get_bits1(&s->gb);
1492
            s->rl_table_index = 2;
1493
            s->rl_chroma_table_index = s->rl_table_index;
1494
            s->dc_table_index = 0; //not used
1495
            s->mv_table_index = 0;
1496
            break;
1497
        case 3:
1498
            s->use_skip_mb_code = get_bits1(&s->gb);
1499
            s->rl_table_index = decode012(&s->gb);
1500
            s->rl_chroma_table_index = s->rl_table_index;
1501

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

    
1504
            s->mv_table_index = get_bits1(&s->gb);
1505
            break;
1506
        case 4:
1507
            s->use_skip_mb_code = get_bits1(&s->gb);
1508

    
1509
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1510
            else                           s->per_mb_rl_table= 0;
1511

    
1512
            if(!s->per_mb_rl_table){
1513
                s->rl_table_index = decode012(&s->gb);
1514
                s->rl_chroma_table_index = s->rl_table_index;
1515
            }
1516

    
1517
            s->dc_table_index = get_bits1(&s->gb);
1518

    
1519
            s->mv_table_index = get_bits1(&s->gb);
1520
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1521
            break;
1522
        }
1523

    
1524
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1525
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1526
                s->use_skip_mb_code,
1527
                s->rl_table_index,
1528
                s->rl_chroma_table_index,
1529
                s->dc_table_index,
1530
                s->mv_table_index,
1531
                s->per_mb_rl_table,
1532
                s->qscale);
1533

    
1534
        if(s->flipflop_rounding){
1535
            s->no_rounding ^= 1;
1536
        }else{
1537
            s->no_rounding = 0;
1538
        }
1539
    }
1540
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1541

    
1542
    s->esc3_level_length= 0;
1543
    s->esc3_run_length= 0;
1544

    
1545
    return 0;
1546
}
1547

    
1548
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1549
{
1550
    int left= buf_size*8 - get_bits_count(&s->gb);
1551
    int length= s->msmpeg4_version>=3 ? 17 : 16;
1552
    /* the alt_bitstream reader could read over the end so we need to check it */
1553
    if(left>=length && left<length+8)
1554
    {
1555
        int fps;
1556

    
1557
        fps= get_bits(&s->gb, 5);
1558
        s->bit_rate= get_bits(&s->gb, 11)*1024;
1559
        if(s->msmpeg4_version>=3)
1560
            s->flipflop_rounding= get_bits1(&s->gb);
1561
        else
1562
            s->flipflop_rounding= 0;
1563

    
1564
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1565
    }
1566
    else if(left<length+8)
1567
    {
1568
        s->flipflop_rounding= 0;
1569
        if(s->msmpeg4_version != 2)
1570
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1571
    }
1572
    else
1573
    {
1574
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1575
    }
1576

    
1577
    return 0;
1578
}
1579

    
1580
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1581
{
1582
    int level, pred;
1583

    
1584
    if(s->msmpeg4_version<=2){
1585
        if (n < 4) {
1586
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1587
        } else {
1588
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1589
        }
1590
        if (level < 0)
1591
            return -1;
1592
        level-=256;
1593
    }else{  //FIXME optimize use unified tables & index
1594
        if (n < 4) {
1595
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1596
        } else {
1597
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1598
        }
1599
        if (level < 0){
1600
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1601
            return -1;
1602
        }
1603

    
1604
        if (level == DC_MAX) {
1605
            level = get_bits(&s->gb, 8);
1606
            if (get_bits1(&s->gb))
1607
                level = -level;
1608
        } else if (level != 0) {
1609
            if (get_bits1(&s->gb))
1610
                level = -level;
1611
        }
1612
    }
1613

    
1614
    if(s->msmpeg4_version==1){
1615
        int32_t *dc_val;
1616
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1617
        level += pred;
1618

    
1619
        /* update predictor */
1620
        *dc_val= level;
1621
    }else{
1622
        int16_t *dc_val;
1623
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1624
        level += pred;
1625

    
1626
        /* update predictor */
1627
        if (n < 4) {
1628
            *dc_val = level * s->y_dc_scale;
1629
        } else {
1630
            *dc_val = level * s->c_dc_scale;
1631
        }
1632
    }
1633

    
1634
    return level;
1635
}
1636

    
1637
//#define ERROR_DETAILS
1638
int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1639
                              int n, int coded, const uint8_t *scan_table)
1640
{
1641
    int level, i, last, run, run_diff;
1642
    int av_uninit(dc_pred_dir);
1643
    RLTable *rl;
1644
    RL_VLC_ELEM *rl_vlc;
1645
    int qmul, qadd;
1646

    
1647
    if (s->mb_intra) {
1648
        qmul=1;
1649
        qadd=0;
1650

    
1651
        /* DC coef */
1652
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1653

    
1654
        if (level < 0){
1655
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1656
            if(s->inter_intra_pred) level=0;
1657
            else                    return -1;
1658
        }
1659
        if (n < 4) {
1660
            rl = &rl_table[s->rl_table_index];
1661
            if(level > 256*s->y_dc_scale){
1662
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1663
                if(!s->inter_intra_pred) return -1;
1664
            }
1665
        } else {
1666
            rl = &rl_table[3 + s->rl_chroma_table_index];
1667
            if(level > 256*s->c_dc_scale){
1668
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1669
                if(!s->inter_intra_pred) return -1;
1670
            }
1671
        }
1672
        block[0] = level;
1673

    
1674
        run_diff = s->msmpeg4_version >= 4;
1675
        i = 0;
1676
        if (!coded) {
1677
            goto not_coded;
1678
        }
1679
        if (s->ac_pred) {
1680
            if (dc_pred_dir == 0)
1681
                scan_table = s->intra_v_scantable.permutated; /* left */
1682
            else
1683
                scan_table = s->intra_h_scantable.permutated; /* top */
1684
        } else {
1685
            scan_table = s->intra_scantable.permutated;
1686
        }
1687
        rl_vlc= rl->rl_vlc[0];
1688
    } else {
1689
        qmul = s->qscale << 1;
1690
        qadd = (s->qscale - 1) | 1;
1691
        i = -1;
1692
        rl = &rl_table[3 + s->rl_table_index];
1693

    
1694
        if(s->msmpeg4_version==2)
1695
            run_diff = 0;
1696
        else
1697
            run_diff = 1;
1698

    
1699
        if (!coded) {
1700
            s->block_last_index[n] = i;
1701
            return 0;
1702
        }
1703
        if(!scan_table)
1704
            scan_table = s->inter_scantable.permutated;
1705
        rl_vlc= rl->rl_vlc[s->qscale];
1706
    }
1707
  {
1708
    OPEN_READER(re, &s->gb);
1709
    for(;;) {
1710
        UPDATE_CACHE(re, &s->gb);
1711
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1712
        if (level==0) {
1713
            int cache;
1714
            cache= GET_CACHE(re, &s->gb);
1715
            /* escape */
1716
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1717
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1718
                    /* third escape */
1719
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1720
                    UPDATE_CACHE(re, &s->gb);
1721
                    if(s->msmpeg4_version<=3){
1722
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1723
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1724
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1725
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
1726
                    }else{
1727
                        int sign;
1728
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1729
                        if(!s->esc3_level_length){
1730
                            int ll;
1731
                            //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1732
                            if(s->qscale<8){
1733
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1734
                                if(ll==0){
1735
                                    ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1736
                                }
1737
                            }else{
1738
                                ll=2;
1739
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1740
                                    ll++;
1741
                                    SKIP_BITS(re, &s->gb, 1);
1742
                                }
1743
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
1744
                            }
1745

    
1746
                            s->esc3_level_length= ll;
1747
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1748
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1749
                            UPDATE_CACHE(re, &s->gb);
1750
                        }
1751
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1752
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
1753

    
1754
                        sign=  SHOW_UBITS(re, &s->gb, 1);
1755
                        SKIP_BITS(re, &s->gb, 1);
1756

    
1757
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1758
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
1759
                        if(sign) level= -level;
1760
                    }
1761
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1762
#if 0 // waste of time / this will detect very few errors
1763
                    {
1764
                        const int abs_level= FFABS(level);
1765
                        const int run1= run - rl->max_run[last][abs_level] - run_diff;
1766
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1767
                            if(abs_level <= rl->max_level[last][run]){
1768
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1769
                                return DECODING_AC_LOST;
1770
                            }
1771
                            if(abs_level <= rl->max_level[last][run]*2){
1772
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1773
                                return DECODING_AC_LOST;
1774
                            }
1775
                            if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1776
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1777
                                return DECODING_AC_LOST;
1778
                            }
1779
                        }
1780
                    }
1781
#endif
1782
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1783
                    if (level>0) level= level * qmul + qadd;
1784
                    else         level= level * qmul - qadd;
1785
#if 0 // waste of time too :(
1786
                    if(level>2048 || level<-2048){
1787
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1788
                        return DECODING_AC_LOST;
1789
                    }
1790
#endif
1791
                    i+= run + 1;
1792
                    if(last) i+=192;
1793
#ifdef ERROR_DETAILS
1794
                if(run==66)
1795
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1796
                else if((i>62 && i<192) || i>192+63)
1797
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1798
#endif
1799
                } else {
1800
                    /* second escape */
1801
#if MIN_CACHE_BITS < 23
1802
                    LAST_SKIP_BITS(re, &s->gb, 2);
1803
                    UPDATE_CACHE(re, &s->gb);
1804
#else
1805
                    SKIP_BITS(re, &s->gb, 2);
1806
#endif
1807
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1808
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1809
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1810
                    LAST_SKIP_BITS(re, &s->gb, 1);
1811
#ifdef ERROR_DETAILS
1812
                if(run==66)
1813
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1814
                else if((i>62 && i<192) || i>192+63)
1815
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1816
#endif
1817
                }
1818
            } else {
1819
                /* first escape */
1820
#if MIN_CACHE_BITS < 22
1821
                LAST_SKIP_BITS(re, &s->gb, 1);
1822
                UPDATE_CACHE(re, &s->gb);
1823
#else
1824
                SKIP_BITS(re, &s->gb, 1);
1825
#endif
1826
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1827
                i+= run;
1828
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1829
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1830
                LAST_SKIP_BITS(re, &s->gb, 1);
1831
#ifdef ERROR_DETAILS
1832
                if(run==66)
1833
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1834
                else if((i>62 && i<192) || i>192+63)
1835
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1836
#endif
1837
            }
1838
        } else {
1839
            i+= run;
1840
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1841
            LAST_SKIP_BITS(re, &s->gb, 1);
1842
#ifdef ERROR_DETAILS
1843
                if(run==66)
1844
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1845
                else if((i>62 && i<192) || i>192+63)
1846
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1847
#endif
1848
        }
1849
        if (i > 62){
1850
            i-= 192;
1851
            if(i&(~63)){
1852
                const int left= get_bits_left(&s->gb);
1853
                if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1854
                    av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1855
                    break;
1856
                }else{
1857
                    av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1858
                    return -1;
1859
                }
1860
            }
1861

    
1862
            block[scan_table[i]] = level;
1863
            break;
1864
        }
1865

    
1866
        block[scan_table[i]] = level;
1867
    }
1868
    CLOSE_READER(re, &s->gb);
1869
  }
1870
 not_coded:
1871
    if (s->mb_intra) {
1872
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1873
        if (s->ac_pred) {
1874
            i = 63; /* XXX: not optimal */
1875
        }
1876
    }
1877
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1878
    s->block_last_index[n] = i;
1879

    
1880
    return 0;
1881
}
1882

    
1883
int ff_msmpeg4_decode_motion(MpegEncContext * s,
1884
                                 int *mx_ptr, int *my_ptr)
1885
{
1886
    MVTable *mv;
1887
    int code, mx, my;
1888

    
1889
    mv = &mv_tables[s->mv_table_index];
1890

    
1891
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1892
    if (code < 0){
1893
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1894
        return -1;
1895
    }
1896
    if (code == mv->n) {
1897
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1898
        mx = get_bits(&s->gb, 6);
1899
        my = get_bits(&s->gb, 6);
1900
    } else {
1901
        mx = mv->table_mvx[code];
1902
        my = mv->table_mvy[code];
1903
    }
1904

    
1905
    mx += *mx_ptr - 32;
1906
    my += *my_ptr - 32;
1907
    /* WARNING : they do not do exactly modulo encoding */
1908
    if (mx <= -64)
1909
        mx += 64;
1910
    else if (mx >= 64)
1911
        mx -= 64;
1912

    
1913
    if (my <= -64)
1914
        my += 64;
1915
    else if (my >= 64)
1916
        my -= 64;
1917
    *mx_ptr = mx;
1918
    *my_ptr = my;
1919
    return 0;
1920
}
1921

    
1922
AVCodec msmpeg4v1_decoder = {
1923
    "msmpeg4v1",
1924
    AVMEDIA_TYPE_VIDEO,
1925
    CODEC_ID_MSMPEG4V1,
1926
    sizeof(MpegEncContext),
1927
    ff_msmpeg4_decode_init,
1928
    NULL,
1929
    ff_h263_decode_end,
1930
    ff_h263_decode_frame,
1931
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1932
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1933
    .pix_fmts= ff_pixfmt_list_420,
1934
};
1935

    
1936
AVCodec msmpeg4v2_decoder = {
1937
    "msmpeg4v2",
1938
    AVMEDIA_TYPE_VIDEO,
1939
    CODEC_ID_MSMPEG4V2,
1940
    sizeof(MpegEncContext),
1941
    ff_msmpeg4_decode_init,
1942
    NULL,
1943
    ff_h263_decode_end,
1944
    ff_h263_decode_frame,
1945
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1946
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1947
    .pix_fmts= ff_pixfmt_list_420,
1948
};
1949

    
1950
AVCodec msmpeg4v3_decoder = {
1951
    "msmpeg4",
1952
    AVMEDIA_TYPE_VIDEO,
1953
    CODEC_ID_MSMPEG4V3,
1954
    sizeof(MpegEncContext),
1955
    ff_msmpeg4_decode_init,
1956
    NULL,
1957
    ff_h263_decode_end,
1958
    ff_h263_decode_frame,
1959
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1960
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1961
    .pix_fmts= ff_pixfmt_list_420,
1962
};
1963

    
1964
AVCodec wmv1_decoder = {
1965
    "wmv1",
1966
    AVMEDIA_TYPE_VIDEO,
1967
    CODEC_ID_WMV1,
1968
    sizeof(MpegEncContext),
1969
    ff_msmpeg4_decode_init,
1970
    NULL,
1971
    ff_h263_decode_end,
1972
    ff_h263_decode_frame,
1973
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1974
    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1975
    .pix_fmts= ff_pixfmt_list_420,
1976
};