Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 2912e87a

History | View | Annotate | Download (61 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 Libav.
9
 *
10
 * Libav 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
 * Libav 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 Libav; 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==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 = get_bits_long(&s->gb, 32);
1399
        if(start_code!=0x00000100){
1400
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1401
            return -1;
1402
        }
1403

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1544
    return 0;
1545
}
1546

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

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

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

    
1576
    return 0;
1577
}
1578

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

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

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

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

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

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

    
1633
    return level;
1634
}
1635

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

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

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

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

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

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

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

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

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

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

    
1851
            block[scan_table[i]] = level;
1852
            break;
1853
        }
1854

    
1855
        block[scan_table[i]] = level;
1856
    }
1857
    CLOSE_READER(re, &s->gb);
1858
  }
1859
 not_coded:
1860
    if (s->mb_intra) {
1861
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1862
        if (s->ac_pred) {
1863
            i = 63; /* XXX: not optimal */
1864
        }
1865
    }
1866
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1867
    s->block_last_index[n] = i;
1868

    
1869
    return 0;
1870
}
1871

    
1872
int ff_msmpeg4_decode_motion(MpegEncContext * s,
1873
                                 int *mx_ptr, int *my_ptr)
1874
{
1875
    MVTable *mv;
1876
    int code, mx, my;
1877

    
1878
    mv = &mv_tables[s->mv_table_index];
1879

    
1880
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1881
    if (code < 0){
1882
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1883
        return -1;
1884
    }
1885
    if (code == mv->n) {
1886
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1887
        mx = get_bits(&s->gb, 6);
1888
        my = get_bits(&s->gb, 6);
1889
    } else {
1890
        mx = mv->table_mvx[code];
1891
        my = mv->table_mvy[code];
1892
    }
1893

    
1894
    mx += *mx_ptr - 32;
1895
    my += *my_ptr - 32;
1896
    /* WARNING : they do not do exactly modulo encoding */
1897
    if (mx <= -64)
1898
        mx += 64;
1899
    else if (mx >= 64)
1900
        mx -= 64;
1901

    
1902
    if (my <= -64)
1903
        my += 64;
1904
    else if (my >= 64)
1905
        my -= 64;
1906
    *mx_ptr = mx;
1907
    *my_ptr = my;
1908
    return 0;
1909
}
1910

    
1911
AVCodec ff_msmpeg4v1_decoder = {
1912
    "msmpeg4v1",
1913
    AVMEDIA_TYPE_VIDEO,
1914
    CODEC_ID_MSMPEG4V1,
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 1"),
1923
    .pix_fmts= ff_pixfmt_list_420,
1924
};
1925

    
1926
AVCodec ff_msmpeg4v2_decoder = {
1927
    "msmpeg4v2",
1928
    AVMEDIA_TYPE_VIDEO,
1929
    CODEC_ID_MSMPEG4V2,
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 2"),
1938
    .pix_fmts= ff_pixfmt_list_420,
1939
};
1940

    
1941
AVCodec ff_msmpeg4v3_decoder = {
1942
    "msmpeg4",
1943
    AVMEDIA_TYPE_VIDEO,
1944
    CODEC_ID_MSMPEG4V3,
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("MPEG-4 part 2 Microsoft variant version 3"),
1953
    .pix_fmts= ff_pixfmt_list_420,
1954
};
1955

    
1956
AVCodec ff_wmv1_decoder = {
1957
    "wmv1",
1958
    AVMEDIA_TYPE_VIDEO,
1959
    CODEC_ID_WMV1,
1960
    sizeof(MpegEncContext),
1961
    ff_msmpeg4_decode_init,
1962
    NULL,
1963
    ff_h263_decode_end,
1964
    ff_h263_decode_frame,
1965
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1966
    .max_lowres= 3,
1967
    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1968
    .pix_fmts= ff_pixfmt_list_420,
1969
};