Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 137c8468

History | View | Annotate | Download (60.9 KB)

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

    
23
/**
24
 * @file msmpeg4.c
25
 * MSMPEG4 backend for ffmpeg encoder and decoder.
26
 */
27

    
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "mpegvideo.h"
31

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

    
41
#define DC_VLC_BITS 9
42
#define CBPY_VLC_BITS 6
43
#define INTER_INTRA_VLC_BITS 3
44
#define V1_INTRA_CBPC_VLC_BITS 6
45
#define V1_INTER_CBPC_VLC_BITS 6
46
#define V2_INTRA_CBPC_VLC_BITS 3
47
#define V2_MB_TYPE_VLC_BITS 7
48
#define MV_VLC_BITS 9
49
#define V2_MV_VLC_BITS 9
50
#define TEX_VLC_BITS 9
51
#define MB_NON_INTRA_VLC_BITS 9
52
#define MB_INTRA_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
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
63
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
64
                                       int n, int coded, const uint8_t *scantable);
65
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
66
static int msmpeg4_decode_motion(MpegEncContext * s, 
67
                                 int *mx_ptr, int *my_ptr);
68
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
69
static void init_h263_dc_for_msmpeg4(void);
70
static inline void msmpeg4_memsetw(short *tab, int val, int n);
71
#ifdef CONFIG_ENCODERS
72
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
73
#endif //CONFIG_ENCODERS
74
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
76
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
77

    
78

    
79
#ifdef DEBUG
80
int intra_count = 0;
81
int frame_count = 0;
82
#endif
83

    
84
#include "msmpeg4data.h"
85

    
86
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
87
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
88
#endif //CONFIG_ENCODERS
89

    
90
#ifdef STATS
91

    
92
const char *st_names[ST_NB] = {
93
    "unknown",
94
    "dc",
95
    "intra_ac",
96
    "inter_ac",
97
    "intra_mb",
98
    "inter_mb",
99
    "mv",
100
};
101

    
102
int st_current_index = 0;
103
unsigned int st_bit_counts[ST_NB];
104
unsigned int st_out_bit_counts[ST_NB];
105

    
106
#define set_stat(var) st_current_index = var;
107

    
108
void print_stats(void)
109
{
110
    unsigned int total;
111
    int i;
112

    
113
    printf("Input:\n");
114
    total = 0;
115
    for(i=0;i<ST_NB;i++)
116
        total += st_bit_counts[i];
117
    if (total == 0)
118
        total = 1;
119
    for(i=0;i<ST_NB;i++) {
120
        printf("%-10s : %10.1f %5.1f%%\n", 
121
               st_names[i], 
122
               (double)st_bit_counts[i] / 8.0, 
123
               (double)st_bit_counts[i] * 100.0 / total);
124
    }
125
    printf("%-10s : %10.1f %5.1f%%\n",
126
           "total", 
127
           (double)total / 8.0, 
128
           100.0);
129

    
130
    printf("Output:\n");
131
    total = 0;
132
    for(i=0;i<ST_NB;i++)
133
        total += st_out_bit_counts[i];
134
    if (total == 0)
135
        total = 1;
136
    for(i=0;i<ST_NB;i++) {
137
        printf("%-10s : %10.1f %5.1f%%\n", 
138
               st_names[i], 
139
               (double)st_out_bit_counts[i] / 8.0, 
140
               (double)st_out_bit_counts[i] * 100.0 / total);
141
    }
142
    printf("%-10s : %10.1f %5.1f%%\n",
143
           "total", 
144
           (double)total / 8.0, 
145
           100.0);
146
}
147

    
148
#else
149

    
150
#define set_stat(var)
151

    
152
#endif
153

    
154
static void common_init(MpegEncContext * s)
155
{
156
    static int inited=0;
157
    
158
    switch(s->msmpeg4_version){
159
    case 1:
160
    case 2:
161
        s->y_dc_scale_table=
162
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
163
        break;
164
    case 3:
165
        if(s->workaround_bugs){
166
            s->y_dc_scale_table= old_ff_y_dc_scale_table;
167
            s->c_dc_scale_table= old_ff_c_dc_scale_table;
168
        } else{
169
            s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
170
            s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
171
        }
172
        break;
173
    case 4:
174
    case 5:
175
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
176
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
177
        break;
178
    }
179

    
180
    
181
    if(s->msmpeg4_version>=4){
182
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
183
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
184
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
185
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
186
    }
187
    //Note the default tables are set in common_init in mpegvideo.c
188
    
189
    if(!inited){
190
        inited=1;
191

    
192
        init_h263_dc_for_msmpeg4();
193
    }
194
}
195

    
196
#ifdef CONFIG_ENCODERS
197

    
198
/* build the table which associate a (x,y) motion vector to a vlc */
199
static void init_mv_table(MVTable *tab)
200
{
201
    int i, x, y;
202

    
203
    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
204
    /* mark all entries as not used */
205
    for(i=0;i<4096;i++)
206
        tab->table_mv_index[i] = tab->n;
207
    
208
    for(i=0;i<tab->n;i++) {
209
        x = tab->table_mvx[i];
210
        y = tab->table_mvy[i];
211
        tab->table_mv_index[(x << 6) | y] = i;
212
    }
213
}
214

    
215
static void code012(PutBitContext *pb, int n)
216
{
217
    if (n == 0) {
218
        put_bits(pb, 1, 0);
219
    } else {
220
        put_bits(pb, 1, 1);
221
        put_bits(pb, 1, (n >= 2));
222
    }
223
}
224

    
225
void ff_msmpeg4_encode_init(MpegEncContext *s)
226
{
227
    static int init_done=0;
228
    int i;
229

    
230
    common_init(s);
231
    if(s->msmpeg4_version>=4){
232
        s->min_qcoeff= -255;
233
        s->max_qcoeff=  255;
234
    }
235

    
236
    if (!init_done) {
237
        /* init various encoding tables */
238
        init_done = 1;
239
        init_mv_table(&mv_tables[0]);
240
        init_mv_table(&mv_tables[1]);
241
        for(i=0;i<NB_RL_TABLES;i++)
242
            init_rl(&rl_table[i]);
243

    
244
        for(i=0; i<NB_RL_TABLES; i++){
245
            int level;
246
            for(level=0; level<=MAX_LEVEL; level++){
247
                int run;
248
                for(run=0; run<=MAX_RUN; run++){
249
                    int last;
250
                    for(last=0; last<2; last++){
251
                        rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
252
                    }
253
                }
254
            }
255
        }
256
    }
257
}
258

    
259
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
260
    int size=0;
261
    int code;
262
    int run_diff= intra ? 0 : 1;
263
    
264
    code = get_rl_index(rl, last, run, level);
265
    size+= rl->table_vlc[code][1];
266
    if (code == rl->n) {
267
        int level1, run1;
268

    
269
        level1 = level - rl->max_level[last][run];
270
        if (level1 < 1) 
271
            goto esc2;
272
        code = get_rl_index(rl, last, run, level1);
273
        if (code == rl->n) {
274
            esc2:
275
            size++;
276
            if (level > MAX_LEVEL)
277
                goto esc3;
278
            run1 = run - rl->max_run[last][level] - run_diff;
279
            if (run1 < 0)
280
                goto esc3;
281
            code = get_rl_index(rl, last, run1, level);
282
            if (code == rl->n) {
283
            esc3:
284
                /* third escape */
285
                size+=1+1+6+8;
286
            } else {
287
                /* second escape */
288
                size+= 1+1+ rl->table_vlc[code][1];
289
            }
290
        } else {
291
            /* first escape */
292
            size+= 1+1+ rl->table_vlc[code][1];
293
        }
294
    } else {
295
        size++;
296
    }
297
    return size;
298
}
299

    
300
static void find_best_tables(MpegEncContext * s)
301
{
302
    int i;
303
    int best       =-1, best_size       =9999999;
304
    int chroma_best=-1, best_chroma_size=9999999;
305

    
306
    for(i=0; i<3; i++){
307
        int level;
308
        int chroma_size=0;
309
        int size=0;
310

    
311
        if(i>0){// ;)
312
            size++; 
313
            chroma_size++;
314
        }
315
        for(level=0; level<=MAX_LEVEL; level++){
316
            int run;
317
            for(run=0; run<=MAX_RUN; run++){
318
                int last;
319
                const int last_size= size + chroma_size;
320
                for(last=0; last<2; last++){
321
                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
322
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
323
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
324
                    
325
                    if(s->pict_type==I_TYPE){
326
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
327
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
328
                    }else{
329
                        size+=        intra_luma_count  *rl_length[i  ][level][run][last]
330
                                     +intra_chroma_count*rl_length[i+3][level][run][last]
331
                                     +inter_count       *rl_length[i+3][level][run][last];
332
                    }                   
333
                }
334
                if(last_size == size+chroma_size) break;
335
            }
336
        }
337
        if(size<best_size){
338
            best_size= size;
339
            best= i;
340
        }
341
        if(chroma_size<best_chroma_size){
342
            best_chroma_size= chroma_size;
343
            chroma_best= i;
344
        }
345
    }
346

    
347
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", 
348
//           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
349
           
350
    if(s->pict_type==P_TYPE) chroma_best= best;
351

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

    
354
    s->rl_table_index       =        best;
355
    s->rl_chroma_table_index= chroma_best;
356
    
357
    if(s->pict_type != s->last_non_b_pict_type){
358
        s->rl_table_index= 2;
359
        if(s->pict_type==I_TYPE)
360
            s->rl_chroma_table_index= 1;
361
        else
362
            s->rl_chroma_table_index= 2;
363
    }
364

    
365
}
366

    
367
/* write MSMPEG4 compatible frame header */
368
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
369
{
370
    find_best_tables(s);
371

    
372
    align_put_bits(&s->pb);
373
    put_bits(&s->pb, 2, s->pict_type - 1);
374

    
375
    put_bits(&s->pb, 5, s->qscale);
376
    if(s->msmpeg4_version<=2){
377
        s->rl_table_index = 2;
378
        s->rl_chroma_table_index = 2;
379
    }
380

    
381
    s->dc_table_index = 1;
382
    s->mv_table_index = 1; /* only if P frame */
383
    s->use_skip_mb_code = 1; /* only if P frame */
384
    s->per_mb_rl_table = 0;
385
    if(s->msmpeg4_version==4)
386
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
387
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
388

    
389
    if (s->pict_type == I_TYPE) {
390
        s->slice_height= s->mb_height/1;
391
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
392
        
393
        if(s->msmpeg4_version==4){
394
            msmpeg4_encode_ext_header(s);
395
            if(s->bit_rate>MBAC_BITRATE)
396
                put_bits(&s->pb, 1, s->per_mb_rl_table);
397
        }
398

    
399
        if(s->msmpeg4_version>2){
400
            if(!s->per_mb_rl_table){
401
                code012(&s->pb, s->rl_chroma_table_index);
402
                code012(&s->pb, s->rl_table_index);
403
            }
404

    
405
            put_bits(&s->pb, 1, s->dc_table_index);
406
        }
407
    } else {
408
        put_bits(&s->pb, 1, s->use_skip_mb_code);
409
        
410
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
411
            put_bits(&s->pb, 1, s->per_mb_rl_table);
412

    
413
        if(s->msmpeg4_version>2){
414
            if(!s->per_mb_rl_table)
415
                code012(&s->pb, s->rl_table_index);
416

    
417
            put_bits(&s->pb, 1, s->dc_table_index);
418

    
419
            put_bits(&s->pb, 1, s->mv_table_index);
420
        }
421
    }
422

    
423
    s->esc3_level_length= 0;
424
    s->esc3_run_length= 0;
425

    
426
#ifdef DEBUG
427
    intra_count = 0;
428
    printf("*****frame %d:\n", frame_count++);
429
#endif
430
}
431

    
432
void msmpeg4_encode_ext_header(MpegEncContext * s)
433
{
434
        put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
435

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

    
438
        if(s->msmpeg4_version>=3)
439
            put_bits(&s->pb, 1, s->flipflop_rounding);
440
        else
441
            assert(s->flipflop_rounding==0);
442
}
443

    
444
#endif //CONFIG_ENCODERS
445

    
446
/* predict coded block */
447
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
448
{
449
    int xy, wrap, pred, a, b, c;
450

    
451
    xy = s->block_index[n];
452
    wrap = s->b8_stride;
453

    
454
    /* B C
455
     * A X 
456
     */
457
    a = s->coded_block[xy - 1       ];
458
    b = s->coded_block[xy - 1 - wrap];
459
    c = s->coded_block[xy     - wrap];
460
    
461
    if (b == c) {
462
        pred = a;
463
    } else {
464
        pred = c;
465
    }
466
    
467
    /* store value */
468
    *coded_block_ptr = &s->coded_block[xy];
469

    
470
    return pred;
471
}
472

    
473
#ifdef CONFIG_ENCODERS
474

    
475
static void msmpeg4_encode_motion(MpegEncContext * s, 
476
                                  int mx, int my)
477
{
478
    int code;
479
    MVTable *mv;
480

    
481
    /* modulo encoding */
482
    /* WARNING : you cannot reach all the MVs even with the modulo
483
       encoding. This is a somewhat strange compromise they took !!!  */
484
    if (mx <= -64)
485
        mx += 64;
486
    else if (mx >= 64)
487
        mx -= 64;
488
    if (my <= -64)
489
        my += 64;
490
    else if (my >= 64)
491
        my -= 64;
492
    
493
    mx += 32;
494
    my += 32;
495
#if 0
496
    if ((unsigned)mx >= 64 ||
497
        (unsigned)my >= 64) 
498
        fprintf(stderr, "error mx=%d my=%d\n", mx, my);
499
#endif
500
    mv = &mv_tables[s->mv_table_index];
501

    
502
    code = mv->table_mv_index[(mx << 6) | my];
503
    set_stat(ST_MV);
504
    put_bits(&s->pb, 
505
             mv->table_mv_bits[code], 
506
             mv->table_mv_code[code]);
507
    if (code == mv->n) {
508
        /* escape : code litterally */
509
        put_bits(&s->pb, 6, mx);
510
        put_bits(&s->pb, 6, my);
511
    }
512
}
513

    
514
static inline void handle_slices(MpegEncContext *s){
515
    if (s->mb_x == 0) {
516
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
517
            if(s->msmpeg4_version < 4){
518
                ff_mpeg4_clean_buffers(s);
519
            }
520
            s->first_slice_line = 1;
521
        } else {
522
            s->first_slice_line = 0; 
523
        }
524
    }
525
}
526

    
527
void msmpeg4_encode_mb(MpegEncContext * s, 
528
                       DCTELEM block[6][64],
529
                       int motion_x, int motion_y)
530
{
531
    int cbp, coded_cbp, i;
532
    int pred_x, pred_y;
533
    uint8_t *coded_block;
534

    
535
    handle_slices(s);
536
    
537
    if (!s->mb_intra) {
538
        /* compute cbp */
539
        set_stat(ST_INTER_MB);
540
        cbp = 0;
541
        for (i = 0; i < 6; i++) {
542
            if (s->block_last_index[i] >= 0)
543
                cbp |= 1 << (5 - i);
544
        }
545
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
546
            /* skip macroblock */
547
            put_bits(&s->pb, 1, 1);
548
            s->last_bits++;
549
            s->misc_bits++;
550
            s->skip_count++;
551

    
552
            return;
553
        }
554
        if (s->use_skip_mb_code)
555
            put_bits(&s->pb, 1, 0);        /* mb coded */
556
        
557
        if(s->msmpeg4_version<=2){
558
            put_bits(&s->pb, 
559
                     v2_mb_type[cbp&3][1], 
560
                     v2_mb_type[cbp&3][0]);
561
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
562
            else             coded_cbp= cbp;
563

    
564
            put_bits(&s->pb, 
565
                     cbpy_tab[coded_cbp>>2][1], 
566
                     cbpy_tab[coded_cbp>>2][0]);
567

    
568
            s->misc_bits += get_bits_diff(s);
569

    
570
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
571
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
572
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
573
        }else{
574
            put_bits(&s->pb, 
575
                     table_mb_non_intra[cbp + 64][1], 
576
                     table_mb_non_intra[cbp + 64][0]);
577

    
578
            s->misc_bits += get_bits_diff(s);
579

    
580
            /* motion vector */
581
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
582
            msmpeg4_encode_motion(s, motion_x - pred_x, 
583
                                  motion_y - pred_y);
584
        }
585

    
586
        s->mv_bits += get_bits_diff(s);
587

    
588
        for (i = 0; i < 6; i++) {
589
            msmpeg4_encode_block(s, block[i], i);
590
        }
591
        s->p_tex_bits += get_bits_diff(s);
592
    } else {
593
        /* compute cbp */
594
        cbp = 0;
595
        coded_cbp = 0;
596
        for (i = 0; i < 6; i++) {
597
            int val, pred;
598
            val = (s->block_last_index[i] >= 1);
599
            cbp |= val << (5 - i);
600
            if (i < 4) {
601
                /* predict value for close blocks only for luma */
602
                pred = coded_block_pred(s, i, &coded_block);
603
                *coded_block = val;
604
                val = val ^ pred;
605
            }
606
            coded_cbp |= val << (5 - i);
607
        }
608
#if 0
609
        if (coded_cbp)
610
            printf("cbp=%x %x\n", cbp, coded_cbp);
611
#endif
612

    
613
        if(s->msmpeg4_version<=2){
614
            if (s->pict_type == I_TYPE) {
615
                put_bits(&s->pb, 
616
                         v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
617
            } else {
618
                if (s->use_skip_mb_code)
619
                    put_bits(&s->pb, 1, 0);        /* mb coded */
620
                put_bits(&s->pb, 
621
                         v2_mb_type[(cbp&3) + 4][1], 
622
                         v2_mb_type[(cbp&3) + 4][0]);
623
            }
624
            put_bits(&s->pb, 1, 0);        /* no AC prediction yet */
625
            put_bits(&s->pb, 
626
                     cbpy_tab[cbp>>2][1], 
627
                     cbpy_tab[cbp>>2][0]);
628
        }else{
629
            if (s->pict_type == I_TYPE) {
630
                set_stat(ST_INTRA_MB);
631
                put_bits(&s->pb, 
632
                         table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
633
            } else {
634
                if (s->use_skip_mb_code)
635
                    put_bits(&s->pb, 1, 0);        /* mb coded */
636
                put_bits(&s->pb, 
637
                         table_mb_non_intra[cbp][1], 
638
                         table_mb_non_intra[cbp][0]);
639
            }
640
            set_stat(ST_INTRA_MB);
641
            put_bits(&s->pb, 1, 0);        /* no AC prediction yet */
642
            if(s->inter_intra_pred){
643
                s->h263_aic_dir=0;
644
                put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
645
            }
646
        }
647
        s->misc_bits += get_bits_diff(s);
648

    
649
        for (i = 0; i < 6; i++) {
650
            msmpeg4_encode_block(s, block[i], i);
651
        }
652
        s->i_tex_bits += get_bits_diff(s);
653
        s->i_count++;
654
    }
655
}
656

    
657
#endif //CONFIG_ENCODERS
658

    
659
/* old ffmpeg msmpeg4v3 mode */
660
static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
661
{
662
    if (s->qscale < 5){
663
        s->y_dc_scale = 8;
664
        s->c_dc_scale = 8;
665
    }else if (s->qscale < 9){
666
        s->y_dc_scale = 2 * s->qscale;
667
        s->c_dc_scale = (s->qscale + 13)>>1;
668
    }else{
669
        s->y_dc_scale = s->qscale + 8;
670
        s->c_dc_scale = (s->qscale + 13)>>1;
671
    }
672
}
673

    
674
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
675
                                    int32_t **dc_val_ptr)
676
{
677
    int i;
678

    
679
    if (n < 4) {
680
        i= 0;
681
    } else {
682
        i= n-3;
683
    }
684
    
685
    *dc_val_ptr= &s->last_dc[i];
686
    return s->last_dc[i]; 
687
}
688

    
689
static int get_dc(uint8_t *src, int stride, int scale)
690
{
691
    int y;
692
    int sum=0;
693
    for(y=0; y<8; y++){
694
        int x;
695
        for(x=0; x<8; x++){
696
            sum+=src[x + y*stride];
697
        }
698
    }
699
    return FASTDIV((sum + (scale>>1)), scale);
700
}
701

    
702
/* dir = 0: left, dir = 1: top prediction */
703
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
704
                             uint16_t **dc_val_ptr, int *dir_ptr)
705
{
706
    int a, b, c, wrap, pred, scale;
707
    int16_t *dc_val;
708

    
709
    /* find prediction */
710
    if (n < 4) {
711
        scale = s->y_dc_scale;
712
    } else {
713
        scale = s->c_dc_scale;
714
    }
715
    
716
    wrap = s->block_wrap[n];
717
    dc_val= s->dc_val[0] + s->block_index[n];
718

    
719
    /* B C
720
     * A X 
721
     */
722
    a = dc_val[ - 1];
723
    b = dc_val[ - 1 - wrap];
724
    c = dc_val[ - wrap];
725
    
726
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
727
        b=c=1024;
728
    }
729

    
730
    /* XXX: the following solution consumes divisions, but it does not
731
       necessitate to modify mpegvideo.c. The problem comes from the
732
       fact they decided to store the quantized DC (which would lead
733
       to problems if Q could vary !) */
734
#if defined ARCH_X86 && !defined PIC
735
    asm volatile(
736
        "movl %3, %%eax                \n\t"
737
        "shrl $1, %%eax                \n\t"
738
        "addl %%eax, %2                \n\t"
739
        "addl %%eax, %1                \n\t"
740
        "addl %0, %%eax                \n\t"
741
        "mull %4                \n\t"
742
        "movl %%edx, %0                \n\t"
743
        "movl %1, %%eax                \n\t"
744
        "mull %4                \n\t"
745
        "movl %%edx, %1                \n\t"
746
        "movl %2, %%eax                \n\t"
747
        "mull %4                \n\t"
748
        "movl %%edx, %2                \n\t"
749
        : "+b" (a), "+c" (b), "+D" (c)
750
        : "g" (scale), "S" (inverse[scale])
751
        : "%eax", "%edx"
752
    );
753
#else
754
    /* #elif defined (ARCH_ALPHA) */
755
    /* Divisions are extremely costly on Alpha; optimize the most
756
       common case. But they are costly everywhere...
757
     */
758
    if (scale == 8) {
759
        a = (a + (8 >> 1)) / 8;
760
        b = (b + (8 >> 1)) / 8;
761
        c = (c + (8 >> 1)) / 8;
762
    } else {
763
        a = FASTDIV((a + (scale >> 1)), scale);
764
        b = FASTDIV((b + (scale >> 1)), scale);
765
        c = FASTDIV((c + (scale >> 1)), scale);
766
    }
767
#endif
768
    /* XXX: WARNING: they did not choose the same test as MPEG4. This
769
       is very important ! */
770
    if(s->msmpeg4_version>3){
771
        if(s->inter_intra_pred){
772
            uint8_t *dest;
773
            int wrap;
774
            
775
            if(n==1){
776
                pred=a;
777
                *dir_ptr = 0;
778
            }else if(n==2){
779
                pred=c;
780
                *dir_ptr = 1;
781
            }else if(n==3){
782
                if (abs(a - b) < abs(b - c)) {
783
                    pred = c;
784
                    *dir_ptr = 1;
785
                } else {
786
                    pred = a;
787
                    *dir_ptr = 0;
788
                }
789
            }else{
790
                if(n<4){
791
                    wrap= s->linesize;
792
                    dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
793
                }else{
794
                    wrap= s->uvlinesize;
795
                    dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
796
                }
797
                if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
798
                else           a= get_dc(dest-8, wrap, scale*8);
799
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
800
                else           c= get_dc(dest-8*wrap, wrap, scale*8);
801
                
802
                if (s->h263_aic_dir==0) {
803
                    pred= a;
804
                    *dir_ptr = 0;
805
                }else if (s->h263_aic_dir==1) {
806
                    if(n==0){
807
                        pred= c;
808
                        *dir_ptr = 1;
809
                    }else{
810
                        pred= a;
811
                        *dir_ptr = 0;
812
                    }
813
                }else if (s->h263_aic_dir==2) {
814
                    if(n==0){
815
                        pred= a;
816
                        *dir_ptr = 0;
817
                    }else{
818
                        pred= c;
819
                        *dir_ptr = 1;
820
                    }
821
                } else {
822
                    pred= c;
823
                    *dir_ptr = 1;
824
                }
825
            }
826
        }else{
827
            if (abs(a - b) < abs(b - c)) {
828
                pred = c;
829
                *dir_ptr = 1;
830
            } else {
831
                pred = a;
832
                *dir_ptr = 0;
833
            }
834
        }
835
    }else{
836
        if (abs(a - b) <= abs(b - c)) {
837
            pred = c;
838
            *dir_ptr = 1;
839
        } else {
840
            pred = a;
841
            *dir_ptr = 0;
842
        }
843
    }
844

    
845
    /* update predictor */
846
    *dc_val_ptr = &dc_val[0];
847
    return pred;
848
}
849

    
850
#define DC_MAX 119
851

    
852
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
853
{
854
    int sign, code;
855
    int pred;
856

    
857
    if(s->msmpeg4_version==1){
858
        int32_t *dc_val;
859
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
860
        
861
        /* update predictor */
862
        *dc_val= level;
863
    }else{
864
        uint16_t *dc_val;
865
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
866

    
867
        /* update predictor */
868
        if (n < 4) {
869
            *dc_val = level * s->y_dc_scale;
870
        } else {
871
            *dc_val = level * s->c_dc_scale;
872
        }
873
    }
874

    
875
    /* do the prediction */
876
    level -= pred;
877

    
878
    if(s->msmpeg4_version<=2){
879
        if (n < 4) {
880
            put_bits(&s->pb, 
881
                     v2_dc_lum_table[level+256][1],
882
                     v2_dc_lum_table[level+256][0]);
883
        }else{
884
            put_bits(&s->pb, 
885
                     v2_dc_chroma_table[level+256][1],
886
                     v2_dc_chroma_table[level+256][0]);
887
        }
888
    }else{
889
        sign = 0;
890
        if (level < 0) {
891
            level = -level;
892
            sign = 1;
893
        }
894
        code = level;
895
        if (code > DC_MAX) 
896
            code = DC_MAX;
897

    
898
        if (s->dc_table_index == 0) {
899
            if (n < 4) {
900
                put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
901
            } else {
902
                put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
903
            }
904
        } else {
905
            if (n < 4) {
906
                put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
907
            } else {
908
                put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
909
            }
910
        }
911
            
912
        if (code == DC_MAX)
913
            put_bits(&s->pb, 8, level);
914
            
915
        if (level != 0) {
916
            put_bits(&s->pb, 1, sign);
917
        }
918
    }
919
}
920

    
921
/* Encoding of a block. Very similar to MPEG4 except for a different
922
   escape coding (same as H263) and more vlc tables.
923
 */
924
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
925
{
926
    int level, run, last, i, j, last_index;
927
    int last_non_zero, sign, slevel;
928
    int code, run_diff, dc_pred_dir;
929
    const RLTable *rl;
930
    const uint8_t *scantable;
931

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

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

    
978
            if(level<=MAX_LEVEL && run<=MAX_RUN){
979
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
980
            }
981
#if 0
982
else
983
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
984
#endif
985
            code = get_rl_index(rl, last, run, level);
986
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
987
            if (code == rl->n) {
988
                int level1, run1;
989

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

    
1044
/****************************************/
1045
/* decoding stuff */
1046

    
1047
static VLC mb_non_intra_vlc[4];
1048
static VLC mb_intra_vlc;
1049
static VLC dc_lum_vlc[2];
1050
static VLC dc_chroma_vlc[2];
1051
static VLC v2_dc_lum_vlc;
1052
static VLC v2_dc_chroma_vlc;
1053
static VLC cbpy_vlc;
1054
static VLC v2_intra_cbpc_vlc;
1055
static VLC v2_mb_type_vlc;
1056
static VLC v2_mv_vlc;
1057
static VLC v1_intra_cbpc_vlc;
1058
static VLC v1_inter_cbpc_vlc;
1059
static VLC inter_intra_vlc;
1060

    
1061
/* this table is practically identical to the one from h263 except that its inverted */
1062
static void init_h263_dc_for_msmpeg4(void)
1063
{
1064
        int level, uni_code, uni_len;
1065

    
1066
        for(level=-256; level<256; level++){
1067
            int size, v, l;
1068
            /* find number of bits */
1069
            size = 0;
1070
            v = abs(level);
1071
            while (v) {
1072
                v >>= 1;
1073
                    size++;
1074
            }
1075

    
1076
            if (level < 0)
1077
                l= (-level) ^ ((1 << size) - 1);
1078
            else
1079
                l= level;
1080

    
1081
            /* luminance h263 */
1082
            uni_code= DCtab_lum[size][0];
1083
            uni_len = DCtab_lum[size][1];
1084
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1085

    
1086
            if (size > 0) {
1087
                uni_code<<=size; uni_code|=l;
1088
                uni_len+=size;
1089
                if (size > 8){
1090
                    uni_code<<=1; uni_code|=1;
1091
                    uni_len++;
1092
                }
1093
            }
1094
            v2_dc_lum_table[level+256][0]= uni_code;
1095
            v2_dc_lum_table[level+256][1]= uni_len;
1096

    
1097
            /* chrominance h263 */
1098
            uni_code= DCtab_chrom[size][0];
1099
            uni_len = DCtab_chrom[size][1];
1100
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1101
            
1102
            if (size > 0) {
1103
                uni_code<<=size; uni_code|=l;
1104
                uni_len+=size;
1105
                if (size > 8){
1106
                    uni_code<<=1; uni_code|=1;
1107
                    uni_len++;
1108
                }
1109
            }
1110
            v2_dc_chroma_table[level+256][0]= uni_code;
1111
            v2_dc_chroma_table[level+256][1]= uni_len;
1112

    
1113
        }
1114
}
1115

    
1116
/* init all vlc decoding tables */
1117
int ff_msmpeg4_decode_init(MpegEncContext *s)
1118
{
1119
    static int done = 0;
1120
    int i;
1121
    MVTable *mv;
1122

    
1123
    common_init(s);
1124

    
1125
    if (!done) {
1126
        done = 1;
1127

    
1128
        for(i=0;i<NB_RL_TABLES;i++) {
1129
            init_rl(&rl_table[i]);
1130
            init_vlc_rl(&rl_table[i]);
1131
        }
1132
        for(i=0;i<2;i++) {
1133
            mv = &mv_tables[i];
1134
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, 
1135
                     mv->table_mv_bits, 1, 1,
1136
                     mv->table_mv_code, 2, 2);
1137
        }
1138

    
1139
        init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 
1140
                 &table0_dc_lum[0][1], 8, 4,
1141
                 &table0_dc_lum[0][0], 8, 4);
1142
        init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1143
                 &table0_dc_chroma[0][1], 8, 4,
1144
                 &table0_dc_chroma[0][0], 8, 4);
1145
        init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 
1146
                 &table1_dc_lum[0][1], 8, 4,
1147
                 &table1_dc_lum[0][0], 8, 4);
1148
        init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1149
                 &table1_dc_chroma[0][1], 8, 4,
1150
                 &table1_dc_chroma[0][0], 8, 4);
1151
    
1152
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 
1153
                 &v2_dc_lum_table[0][1], 8, 4,
1154
                 &v2_dc_lum_table[0][0], 8, 4);
1155
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 
1156
                 &v2_dc_chroma_table[0][1], 8, 4,
1157
                 &v2_dc_chroma_table[0][0], 8, 4);
1158
    
1159
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1160
                 &cbpy_tab[0][1], 2, 1,
1161
                 &cbpy_tab[0][0], 2, 1);
1162
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1163
                 &v2_intra_cbpc[0][1], 2, 1,
1164
                 &v2_intra_cbpc[0][0], 2, 1);
1165
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1166
                 &v2_mb_type[0][1], 2, 1,
1167
                 &v2_mb_type[0][0], 2, 1);
1168
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1169
                 &mvtab[0][1], 2, 1,
1170
                 &mvtab[0][0], 2, 1);
1171

    
1172
        for(i=0; i<4; i++){
1173
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, 
1174
                     &wmv2_inter_table[i][0][1], 8, 4,
1175
                     &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1176
        }
1177
        
1178
        init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64, 
1179
                 &table_mb_intra[0][1], 4, 2,
1180
                 &table_mb_intra[0][0], 4, 2);
1181
        
1182
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, 
1183
                 intra_MCBPC_bits, 1, 1,
1184
                 intra_MCBPC_code, 1, 1);
1185
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25, 
1186
                 inter_MCBPC_bits, 1, 1,
1187
                 inter_MCBPC_code, 1, 1);
1188
        
1189
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 
1190
                 &table_inter_intra[0][1], 2, 1,
1191
                 &table_inter_intra[0][0], 2, 1);
1192
    }
1193
    
1194
    switch(s->msmpeg4_version){
1195
    case 1:
1196
    case 2:
1197
        s->decode_mb= msmpeg4v12_decode_mb;
1198
        break;
1199
    case 3:
1200
    case 4:
1201
        s->decode_mb= msmpeg4v34_decode_mb;
1202
        break;
1203
    case 5:
1204
        s->decode_mb= wmv2_decode_mb;
1205
        break;
1206
    }
1207
    
1208
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1209
    
1210
    return 0;
1211
}
1212

    
1213
static int decode012(GetBitContext *gb)
1214
{
1215
    int n;
1216
    n = get_bits1(gb);
1217
    if (n == 0)
1218
        return 0;
1219
    else
1220
        return get_bits1(gb) + 1;
1221
}
1222

    
1223
int msmpeg4_decode_picture_header(MpegEncContext * s)
1224
{
1225
    int code;
1226

    
1227
#if 0
1228
{
1229
int i;
1230
for(i=0; i<s->gb.size_in_bits; i++)
1231
    printf("%d", get_bits1(&s->gb));
1232
//    get_bits1(&s->gb);
1233
printf("END\n");
1234
return -1;
1235
}
1236
#endif
1237

    
1238
    if(s->msmpeg4_version==1){
1239
        int start_code, num;
1240
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1241
        if(start_code!=0x00000100){
1242
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1243
            return -1;
1244
        }
1245

    
1246
        num= get_bits(&s->gb, 5); // frame number */
1247
    }
1248

    
1249
    s->pict_type = get_bits(&s->gb, 2) + 1;
1250
    if (s->pict_type != I_TYPE &&
1251
        s->pict_type != P_TYPE){
1252
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1253
        return -1;
1254
    }
1255
#if 0
1256
{
1257
    static int had_i=0;
1258
    if(s->pict_type == I_TYPE) had_i=1;
1259
    if(!had_i) return -1;
1260
}
1261
#endif
1262
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1263
    if(s->qscale==0){
1264
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1265
        return -1;
1266
    }
1267

    
1268
    if (s->pict_type == I_TYPE) {
1269
        code = get_bits(&s->gb, 5); 
1270
        if(s->msmpeg4_version==1){
1271
            if(code==0 || code>s->mb_height){
1272
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1273
                return -1;
1274
            }
1275

    
1276
            s->slice_height = code;
1277
        }else{
1278
            /* 0x17: one slice, 0x18: two slices, ... */
1279
            if (code < 0x17){
1280
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1281
                return -1;
1282
            }
1283

    
1284
            s->slice_height = s->mb_height / (code - 0x16);
1285
        }
1286

    
1287
        switch(s->msmpeg4_version){
1288
        case 1:
1289
        case 2:
1290
            s->rl_chroma_table_index = 2;
1291
            s->rl_table_index = 2;
1292

    
1293
            s->dc_table_index = 0; //not used
1294
            break;
1295
        case 3:
1296
            s->rl_chroma_table_index = decode012(&s->gb);
1297
            s->rl_table_index = decode012(&s->gb);
1298

    
1299
            s->dc_table_index = get_bits1(&s->gb);
1300
            break;
1301
        case 4:
1302
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1303

    
1304
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1305
            else                           s->per_mb_rl_table= 0;
1306
            
1307
            if(!s->per_mb_rl_table){
1308
                s->rl_chroma_table_index = decode012(&s->gb);
1309
                s->rl_table_index = decode012(&s->gb);
1310
            }
1311

    
1312
            s->dc_table_index = get_bits1(&s->gb);
1313
            s->inter_intra_pred= 0;
1314
            break;
1315
        }
1316
        s->no_rounding = 1;
1317
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1318
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n", 
1319
                s->qscale,
1320
                s->rl_chroma_table_index,
1321
                s->rl_table_index, 
1322
                s->dc_table_index,
1323
                s->per_mb_rl_table,
1324
                s->slice_height);
1325
    } else {
1326
        switch(s->msmpeg4_version){
1327
        case 1:
1328
        case 2:
1329
            if(s->msmpeg4_version==1)
1330
                s->use_skip_mb_code = 1;
1331
            else
1332
                s->use_skip_mb_code = get_bits1(&s->gb);
1333
            s->rl_table_index = 2;
1334
            s->rl_chroma_table_index = s->rl_table_index;
1335
            s->dc_table_index = 0; //not used
1336
            s->mv_table_index = 0;
1337
            break;
1338
        case 3:
1339
            s->use_skip_mb_code = get_bits1(&s->gb);
1340
            s->rl_table_index = decode012(&s->gb);
1341
            s->rl_chroma_table_index = s->rl_table_index;
1342

    
1343
            s->dc_table_index = get_bits1(&s->gb);
1344

    
1345
            s->mv_table_index = get_bits1(&s->gb);
1346
            break;
1347
        case 4:
1348
            s->use_skip_mb_code = get_bits1(&s->gb);
1349

    
1350
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1351
            else                           s->per_mb_rl_table= 0;
1352

    
1353
            if(!s->per_mb_rl_table){
1354
                s->rl_table_index = decode012(&s->gb);
1355
                s->rl_chroma_table_index = s->rl_table_index;
1356
            }
1357

    
1358
            s->dc_table_index = get_bits1(&s->gb);
1359

    
1360
            s->mv_table_index = get_bits1(&s->gb);
1361
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1362
            break;
1363
        }
1364
        
1365
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1366
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n", 
1367
                s->use_skip_mb_code, 
1368
                s->rl_table_index, 
1369
                s->rl_chroma_table_index, 
1370
                s->dc_table_index,
1371
                s->mv_table_index,
1372
                s->per_mb_rl_table,
1373
                s->qscale);
1374

    
1375
        if(s->flipflop_rounding){
1376
            s->no_rounding ^= 1;
1377
        }else{
1378
            s->no_rounding = 0;
1379
        }
1380
    }
1381
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1382

    
1383
    s->esc3_level_length= 0;
1384
    s->esc3_run_length= 0;
1385

    
1386
#ifdef DEBUG
1387
    printf("*****frame %d:\n", frame_count++);
1388
#endif
1389
    return 0;
1390
}
1391

    
1392
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1393
{
1394
    int left= buf_size*8 - get_bits_count(&s->gb);
1395
    int length= s->msmpeg4_version>=3 ? 17 : 16;
1396
    /* the alt_bitstream reader could read over the end so we need to check it */
1397
    if(left>=length && left<length+8)
1398
    {
1399
        int fps;
1400

    
1401
        fps= get_bits(&s->gb, 5);
1402
        s->bit_rate= get_bits(&s->gb, 11)*1024;
1403
        if(s->msmpeg4_version>=3)
1404
            s->flipflop_rounding= get_bits1(&s->gb);
1405
        else
1406
            s->flipflop_rounding= 0;
1407

    
1408
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1409
    }
1410
    else if(left<length+8)
1411
    {
1412
        s->flipflop_rounding= 0;
1413
        if(s->msmpeg4_version != 2)
1414
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1415
    }
1416
    else
1417
    {
1418
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1419
    }
1420

    
1421
    return 0;
1422
}
1423

    
1424
static inline void msmpeg4_memsetw(short *tab, int val, int n)
1425
{
1426
    int i;
1427
    for(i=0;i<n;i++)
1428
        tab[i] = val;
1429
}
1430

    
1431
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1432
{
1433
    int range, bit_size, sign, code, bits;
1434

    
1435
    if (val == 0) {
1436
        /* zero vector */
1437
        code = 0;
1438
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1439
    } else {
1440
        bit_size = s->f_code - 1;
1441
        range = 1 << bit_size;
1442
        if (val <= -64)
1443
            val += 64;
1444
        else if (val >= 64)
1445
            val -= 64;
1446

    
1447
        if (val >= 0) {
1448
            sign = 0;
1449
        } else {
1450
            val = -val;
1451
            sign = 1;
1452
        }
1453
        val--;
1454
        code = (val >> bit_size) + 1;
1455
        bits = val & (range - 1);
1456

    
1457
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1458
        if (bit_size > 0) {
1459
            put_bits(&s->pb, bit_size, bits);
1460
        }
1461
    }
1462
}
1463

    
1464
/* this is identical to h263 except that its range is multiplied by 2 */
1465
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1466
{
1467
    int code, val, sign, shift;
1468

    
1469
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1470
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1471
    if (code < 0)
1472
        return 0xffff;
1473

    
1474
    if (code == 0)
1475
        return pred;
1476
    sign = get_bits1(&s->gb);
1477
    shift = f_code - 1;
1478
    val = code;
1479
    if (shift) {
1480
        val = (val - 1) << shift;
1481
        val |= get_bits(&s->gb, shift);
1482
        val++;
1483
    }
1484
    if (sign)
1485
        val = -val;
1486

    
1487
    val += pred;
1488
    if (val <= -64)
1489
        val += 64;
1490
    else if (val >= 64)
1491
        val -= 64;
1492

    
1493
    return val;
1494
}
1495

    
1496
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1497
{
1498
    int cbp, code, i;
1499
    
1500
    if (s->pict_type == P_TYPE) {
1501
        if (s->use_skip_mb_code) {
1502
            if (get_bits1(&s->gb)) {
1503
                /* skip mb */
1504
                s->mb_intra = 0;
1505
                for(i=0;i<6;i++)
1506
                    s->block_last_index[i] = -1;
1507
                s->mv_dir = MV_DIR_FORWARD;
1508
                s->mv_type = MV_TYPE_16X16;
1509
                s->mv[0][0][0] = 0;
1510
                s->mv[0][0][1] = 0;
1511
                s->mb_skiped = 1;
1512
                return 0;
1513
            }
1514
        }
1515

    
1516
        if(s->msmpeg4_version==2)
1517
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1518
        else
1519
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1520
        if(code<0 || code>7){
1521
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1522
            return -1;
1523
        }
1524

    
1525
        s->mb_intra = code >>2;
1526
    
1527
        cbp = code & 0x3;
1528
    } else {
1529
        s->mb_intra = 1;
1530
        if(s->msmpeg4_version==2)
1531
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1532
        else
1533
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1534
        if(cbp<0 || cbp>3){
1535
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1536
            return -1;
1537
        }
1538
    }
1539

    
1540
    if (!s->mb_intra) {
1541
        int mx, my, cbpy;
1542
        
1543
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1544
        if(cbpy<0){
1545
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1546
            return -1;
1547
        }
1548

    
1549
        cbp|= cbpy<<2;
1550
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1551
        
1552
        h263_pred_motion(s, 0, 0, &mx, &my);
1553
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1554
        my= msmpeg4v2_decode_motion(s, my, 1);
1555
        
1556
        s->mv_dir = MV_DIR_FORWARD;
1557
        s->mv_type = MV_TYPE_16X16;
1558
        s->mv[0][0][0] = mx;
1559
        s->mv[0][0][1] = my;
1560
    } else {
1561
        if(s->msmpeg4_version==2){
1562
            s->ac_pred = get_bits1(&s->gb);
1563
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1564
        } else{
1565
            s->ac_pred = 0;
1566
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1567
            if(s->pict_type==P_TYPE) cbp^=0x3C;
1568
        }
1569
    }
1570

    
1571
    for (i = 0; i < 6; i++) {
1572
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1573
        {
1574
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1575
             return -1;
1576
        }
1577
    }
1578
    return 0;
1579
}
1580

    
1581
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1582
{
1583
    int cbp, code, i;
1584
    uint8_t *coded_val;
1585
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1586

    
1587
    if (s->pict_type == P_TYPE) {
1588
        set_stat(ST_INTER_MB);
1589
        if (s->use_skip_mb_code) {
1590
            if (get_bits1(&s->gb)) {
1591
                /* skip mb */
1592
                s->mb_intra = 0;
1593
                for(i=0;i<6;i++)
1594
                    s->block_last_index[i] = -1;
1595
                s->mv_dir = MV_DIR_FORWARD;
1596
                s->mv_type = MV_TYPE_16X16;
1597
                s->mv[0][0][0] = 0;
1598
                s->mv[0][0][1] = 0;
1599
                s->mb_skiped = 1;
1600
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1601

    
1602
                return 0;
1603
            }
1604
        }
1605
        
1606
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1607
        if (code < 0)
1608
            return -1;
1609
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1610
        s->mb_intra = (~code & 0x40) >> 6;
1611
            
1612
        cbp = code & 0x3f;
1613
    } else {
1614
        set_stat(ST_INTRA_MB);
1615
        s->mb_intra = 1;
1616
        code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1617
        if (code < 0)
1618
            return -1;
1619
        /* predict coded block pattern */
1620
        cbp = 0;
1621
        for(i=0;i<6;i++) {
1622
            int val = ((code >> (5 - i)) & 1);
1623
            if (i < 4) {
1624
                int pred = coded_block_pred(s, i, &coded_val);
1625
                val = val ^ pred;
1626
                *coded_val = val;
1627
            }
1628
            cbp |= val << (5 - i);
1629
        }
1630
    }
1631

    
1632
    if (!s->mb_intra) {
1633
        int mx, my;
1634
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1635
        if(s->per_mb_rl_table && cbp){
1636
            s->rl_table_index = decode012(&s->gb);
1637
            s->rl_chroma_table_index = s->rl_table_index;
1638
        }
1639
        set_stat(ST_MV);
1640
        h263_pred_motion(s, 0, 0, &mx, &my);
1641
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1642
            return -1;
1643
        s->mv_dir = MV_DIR_FORWARD;
1644
        s->mv_type = MV_TYPE_16X16;
1645
        s->mv[0][0][0] = mx;
1646
        s->mv[0][0][1] = my;
1647
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1648
    } else {
1649
//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));
1650
        set_stat(ST_INTRA_MB);
1651
        s->ac_pred = get_bits1(&s->gb);
1652
        *mb_type_ptr = MB_TYPE_INTRA;
1653
        if(s->inter_intra_pred){
1654
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1655
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1656
        }
1657
        if(s->per_mb_rl_table && cbp){
1658
            s->rl_table_index = decode012(&s->gb);
1659
            s->rl_chroma_table_index = s->rl_table_index;
1660
        }
1661
    }
1662

    
1663
    for (i = 0; i < 6; i++) {
1664
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1665
        {
1666
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1667
            return -1;
1668
        }
1669
    }
1670
    
1671
    return 0;
1672
}
1673
//#define ERROR_DETAILS
1674
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1675
                              int n, int coded, const uint8_t *scan_table)
1676
{
1677
    int level, i, last, run, run_diff;
1678
    int dc_pred_dir;
1679
    RLTable *rl;
1680
    RL_VLC_ELEM *rl_vlc;
1681
    int qmul, qadd;
1682

    
1683
    if (s->mb_intra) {
1684
        qmul=1;
1685
        qadd=0;
1686

    
1687
        /* DC coef */
1688
        set_stat(ST_DC);
1689
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1690
        
1691
        if (level < 0){
1692
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1693
            if(s->inter_intra_pred) level=0;
1694
            else                    return -1;
1695
        }
1696
        if (n < 4) {
1697
            rl = &rl_table[s->rl_table_index];
1698
            if(level > 256*s->y_dc_scale){
1699
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1700
                if(!s->inter_intra_pred) return -1;
1701
            }
1702
        } else {
1703
            rl = &rl_table[3 + s->rl_chroma_table_index];
1704
            if(level > 256*s->c_dc_scale){
1705
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1706
                if(!s->inter_intra_pred) return -1;
1707
            }
1708
        }
1709
        block[0] = level;
1710

    
1711
        run_diff = 0;
1712
        i = 0;
1713
        if (!coded) {
1714
            goto not_coded;
1715
        }
1716
        if (s->ac_pred) {
1717
            if (dc_pred_dir == 0) 
1718
                scan_table = s->intra_v_scantable.permutated; /* left */
1719
            else
1720
                scan_table = s->intra_h_scantable.permutated; /* top */
1721
        } else {
1722
            scan_table = s->intra_scantable.permutated;
1723
        }
1724
        set_stat(ST_INTRA_AC);
1725
        rl_vlc= rl->rl_vlc[0];
1726
    } else {
1727
        qmul = s->qscale << 1;
1728
        qadd = (s->qscale - 1) | 1;
1729
        i = -1;
1730
        rl = &rl_table[3 + s->rl_table_index];
1731

    
1732
        if(s->msmpeg4_version==2)
1733
            run_diff = 0;
1734
        else
1735
            run_diff = 1;
1736

    
1737
        if (!coded) {
1738
            s->block_last_index[n] = i;
1739
            return 0;
1740
        }
1741
        if(!scan_table)
1742
            scan_table = s->inter_scantable.permutated;
1743
        set_stat(ST_INTER_AC);
1744
        rl_vlc= rl->rl_vlc[s->qscale];
1745
    }
1746
  {
1747
    OPEN_READER(re, &s->gb);
1748
    for(;;) {
1749
        UPDATE_CACHE(re, &s->gb);
1750
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1751
        if (level==0) {
1752
            int cache;
1753
            cache= GET_CACHE(re, &s->gb);
1754
            /* escape */
1755
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1756
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1757
                    /* third escape */
1758
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1759
                    UPDATE_CACHE(re, &s->gb);
1760
                    if(s->msmpeg4_version<=3){
1761
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1762
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1763
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1764
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
1765
                    }else{                        
1766
                        int sign;
1767
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1768
                        if(!s->esc3_level_length){
1769
                            int ll;
1770
                            //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1771
                            if(s->qscale<8){
1772
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1773
                                if(ll==0){
1774
                                    if(SHOW_UBITS(re, &s->gb, 1)) av_log(s->avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1775
                                    SKIP_BITS(re, &s->gb, 1);
1776
                                    ll=8;
1777
                                }
1778
                            }else{
1779
                                ll=2;
1780
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1781
                                    ll++;
1782
                                    SKIP_BITS(re, &s->gb, 1);
1783
                                }
1784
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
1785
                            }
1786

    
1787
                            s->esc3_level_length= ll;
1788
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1789
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1790
                            UPDATE_CACHE(re, &s->gb);
1791
                        }
1792
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length); 
1793
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
1794
                        
1795
                        sign=  SHOW_UBITS(re, &s->gb, 1); 
1796
                        SKIP_BITS(re, &s->gb, 1);
1797
                        
1798
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); 
1799
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
1800
                        if(sign) level= -level;
1801
                    }
1802
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1803
#if 0 // waste of time / this will detect very few errors
1804
                    {
1805
                        const int abs_level= ABS(level);
1806
                        const int run1= run - rl->max_run[last][abs_level] - run_diff;
1807
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1808
                            if(abs_level <= rl->max_level[last][run]){
1809
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1810
                                return DECODING_AC_LOST;
1811
                            }
1812
                            if(abs_level <= rl->max_level[last][run]*2){
1813
                                fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1814
                                return DECODING_AC_LOST;
1815
                            }
1816
                            if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1817
                                fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1818
                                return DECODING_AC_LOST;
1819
                            }
1820
                        }
1821
                    }
1822
#endif
1823
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1824
                    if (level>0) level= level * qmul + qadd;
1825
                    else         level= level * qmul - qadd;
1826
#if 0 // waste of time too :(
1827
                    if(level>2048 || level<-2048){
1828
                        fprintf(stderr, "|level| overflow in 3. esc\n");
1829
                        return DECODING_AC_LOST;
1830
                    }
1831
#endif
1832
                    i+= run + 1;
1833
                    if(last) i+=192;
1834
#ifdef ERROR_DETAILS
1835
                if(run==66)
1836
                    fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1837
                else if((i>62 && i<192) || i>192+63)
1838
                    fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1839
#endif
1840
                } else {
1841
                    /* second escape */
1842
#if MIN_CACHE_BITS < 23
1843
                    LAST_SKIP_BITS(re, &s->gb, 2);
1844
                    UPDATE_CACHE(re, &s->gb);
1845
#else
1846
                    SKIP_BITS(re, &s->gb, 2);
1847
#endif
1848
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1849
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1850
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1851
                    LAST_SKIP_BITS(re, &s->gb, 1);
1852
#ifdef ERROR_DETAILS
1853
                if(run==66)
1854
                    fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1855
                else if((i>62 && i<192) || i>192+63)
1856
                    fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1857
#endif
1858
                }
1859
            } else {
1860
                /* first escape */
1861
#if MIN_CACHE_BITS < 22
1862
                LAST_SKIP_BITS(re, &s->gb, 1);
1863
                UPDATE_CACHE(re, &s->gb);
1864
#else
1865
                SKIP_BITS(re, &s->gb, 1);
1866
#endif
1867
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1868
                i+= run;
1869
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1870
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1871
                LAST_SKIP_BITS(re, &s->gb, 1);
1872
#ifdef ERROR_DETAILS
1873
                if(run==66)
1874
                    fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1875
                else if((i>62 && i<192) || i>192+63)
1876
                    fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1877
#endif
1878
            }
1879
        } else {
1880
            i+= run;
1881
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1882
            LAST_SKIP_BITS(re, &s->gb, 1);
1883
#ifdef ERROR_DETAILS
1884
                if(run==66)
1885
                    fprintf(stderr, "illegal vlc code level=%d\n", level);
1886
                else if((i>62 && i<192) || i>192+63)
1887
                    fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1888
#endif
1889
        }
1890
        if (i > 62){
1891
            i-= 192;
1892
            if(i&(~63)){
1893
                const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1894
                if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1895
                    av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1896
                    break;
1897
                }else{
1898
                    av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1899
                    return -1;
1900
                }
1901
            }
1902

    
1903
            block[scan_table[i]] = level;
1904
            break;
1905
        }
1906

    
1907
        block[scan_table[i]] = level;
1908
    }
1909
    CLOSE_READER(re, &s->gb);
1910
  }
1911
 not_coded:
1912
    if (s->mb_intra) {
1913
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1914
        if (s->ac_pred) {
1915
            i = 63; /* XXX: not optimal */
1916
        }
1917
    }
1918
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1919
    s->block_last_index[n] = i;
1920
    
1921
    return 0;
1922
}
1923

    
1924
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1925
{
1926
    int level, pred;
1927

    
1928
    if(s->msmpeg4_version<=2){
1929
        if (n < 4) {
1930
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1931
        } else {
1932
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1933
        }
1934
        if (level < 0) 
1935
            return -1;
1936
        level-=256;
1937
    }else{  //FIXME optimize use unified tables & index
1938
        if (n < 4) {
1939
            level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1940
        } else {
1941
            level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1942
        }
1943
        if (level < 0){
1944
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1945
            return -1;
1946
        }
1947

    
1948
        if (level == DC_MAX) {
1949
            level = get_bits(&s->gb, 8);
1950
            if (get_bits1(&s->gb))
1951
                level = -level;
1952
        } else if (level != 0) {
1953
            if (get_bits1(&s->gb))
1954
                level = -level;
1955
        }
1956
    }
1957

    
1958
    if(s->msmpeg4_version==1){
1959
        int32_t *dc_val;
1960
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1961
        level += pred;
1962
        
1963
        /* update predictor */
1964
        *dc_val= level;
1965
    }else{
1966
        uint16_t *dc_val;
1967
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1968
        level += pred;
1969

    
1970
        /* update predictor */
1971
        if (n < 4) {
1972
            *dc_val = level * s->y_dc_scale;
1973
        } else {
1974
            *dc_val = level * s->c_dc_scale;
1975
        }
1976
    }
1977

    
1978
    return level;
1979
}
1980

    
1981
static int msmpeg4_decode_motion(MpegEncContext * s, 
1982
                                 int *mx_ptr, int *my_ptr)
1983
{
1984
    MVTable *mv;
1985
    int code, mx, my;
1986

    
1987
    mv = &mv_tables[s->mv_table_index];
1988

    
1989
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1990
    if (code < 0){
1991
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1992
        return -1;
1993
    }
1994
    if (code == mv->n) {
1995
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1996
        mx = get_bits(&s->gb, 6);
1997
        my = get_bits(&s->gb, 6);
1998
    } else {
1999
        mx = mv->table_mvx[code];
2000
        my = mv->table_mvy[code];
2001
    }
2002

    
2003
    mx += *mx_ptr - 32;
2004
    my += *my_ptr - 32;
2005
    /* WARNING : they do not do exactly modulo encoding */
2006
    if (mx <= -64)
2007
        mx += 64;
2008
    else if (mx >= 64)
2009
        mx -= 64;
2010

    
2011
    if (my <= -64)
2012
        my += 64;
2013
    else if (my >= 64)
2014
        my -= 64;
2015
    *mx_ptr = mx;
2016
    *my_ptr = my;
2017
    return 0;
2018
}
2019

    
2020
/* cleanest way to support it
2021
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2022
 * as allmost everything would be in the common file 
2023
 */
2024
#include "wmv2.c"