Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ 650cec0c

History | View | Annotate | Download (60.6 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], 1);
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
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
660
                                    int32_t **dc_val_ptr)
661
{
662
    int i;
663

    
664
    if (n < 4) {
665
        i= 0;
666
    } else {
667
        i= n-3;
668
    }
669
    
670
    *dc_val_ptr= &s->last_dc[i];
671
    return s->last_dc[i]; 
672
}
673

    
674
static int get_dc(uint8_t *src, int stride, int scale)
675
{
676
    int y;
677
    int sum=0;
678
    for(y=0; y<8; y++){
679
        int x;
680
        for(x=0; x<8; x++){
681
            sum+=src[x + y*stride];
682
        }
683
    }
684
    return FASTDIV((sum + (scale>>1)), scale);
685
}
686

    
687
/* dir = 0: left, dir = 1: top prediction */
688
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
689
                             uint16_t **dc_val_ptr, int *dir_ptr)
690
{
691
    int a, b, c, wrap, pred, scale;
692
    int16_t *dc_val;
693

    
694
    /* find prediction */
695
    if (n < 4) {
696
        scale = s->y_dc_scale;
697
    } else {
698
        scale = s->c_dc_scale;
699
    }
700
    
701
    wrap = s->block_wrap[n];
702
    dc_val= s->dc_val[0] + s->block_index[n];
703

    
704
    /* B C
705
     * A X 
706
     */
707
    a = dc_val[ - 1];
708
    b = dc_val[ - 1 - wrap];
709
    c = dc_val[ - wrap];
710
    
711
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
712
        b=c=1024;
713
    }
714

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

    
830
    /* update predictor */
831
    *dc_val_ptr = &dc_val[0];
832
    return pred;
833
}
834

    
835
#define DC_MAX 119
836

    
837
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
838
{
839
    int sign, code;
840
    int pred;
841

    
842
    if(s->msmpeg4_version==1){
843
        int32_t *dc_val;
844
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
845
        
846
        /* update predictor */
847
        *dc_val= level;
848
    }else{
849
        uint16_t *dc_val;
850
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
851

    
852
        /* update predictor */
853
        if (n < 4) {
854
            *dc_val = level * s->y_dc_scale;
855
        } else {
856
            *dc_val = level * s->c_dc_scale;
857
        }
858
    }
859

    
860
    /* do the prediction */
861
    level -= pred;
862

    
863
    if(s->msmpeg4_version<=2){
864
        if (n < 4) {
865
            put_bits(&s->pb, 
866
                     v2_dc_lum_table[level+256][1],
867
                     v2_dc_lum_table[level+256][0]);
868
        }else{
869
            put_bits(&s->pb, 
870
                     v2_dc_chroma_table[level+256][1],
871
                     v2_dc_chroma_table[level+256][0]);
872
        }
873
    }else{
874
        sign = 0;
875
        if (level < 0) {
876
            level = -level;
877
            sign = 1;
878
        }
879
        code = level;
880
        if (code > DC_MAX) 
881
            code = DC_MAX;
882

    
883
        if (s->dc_table_index == 0) {
884
            if (n < 4) {
885
                put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
886
            } else {
887
                put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
888
            }
889
        } else {
890
            if (n < 4) {
891
                put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
892
            } else {
893
                put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
894
            }
895
        }
896
            
897
        if (code == DC_MAX)
898
            put_bits(&s->pb, 8, level);
899
            
900
        if (level != 0) {
901
            put_bits(&s->pb, 1, sign);
902
        }
903
    }
904
}
905

    
906
/* Encoding of a block. Very similar to MPEG4 except for a different
907
   escape coding (same as H263) and more vlc tables.
908
 */
909
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
910
{
911
    int level, run, last, i, j, last_index;
912
    int last_non_zero, sign, slevel;
913
    int code, run_diff, dc_pred_dir;
914
    const RLTable *rl;
915
    const uint8_t *scantable;
916

    
917
    if (s->mb_intra) {
918
        set_stat(ST_DC);
919
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
920
        i = 1;
921
        if (n < 4) {
922
            rl = &rl_table[s->rl_table_index];
923
        } else {
924
            rl = &rl_table[3 + s->rl_chroma_table_index];
925
        }
926
        run_diff = 0;
927
        scantable= s->intra_scantable.permutated;
928
        set_stat(ST_INTRA_AC);
929
    } else {
930
        i = 0;
931
        rl = &rl_table[3 + s->rl_table_index];
932
        if(s->msmpeg4_version<=2)
933
            run_diff = 0;
934
        else
935
            run_diff = 1;
936
        scantable= s->inter_scantable.permutated;
937
        set_stat(ST_INTER_AC);
938
    }
939

    
940
    /* recalculate block_last_index for M$ wmv1 */
941
    if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
942
        for(last_index=63; last_index>=0; last_index--){
943
            if(block[scantable[last_index]]) break;
944
        }
945
        s->block_last_index[n]= last_index;
946
    }else
947
        last_index = s->block_last_index[n];
948
    /* AC coefs */
949
    last_non_zero = i - 1;
950
    for (; i <= last_index; i++) {
951
        j = scantable[i];
952
        level = block[j];
953
        if (level) {
954
            run = i - last_non_zero - 1;
955
            last = (i == last_index);
956
            sign = 0;
957
            slevel = level;
958
            if (level < 0) {
959
                sign = 1;
960
                level = -level;
961
            }
962

    
963
            if(level<=MAX_LEVEL && run<=MAX_RUN){
964
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
965
            }
966
#if 0
967
else
968
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
969
#endif
970
            code = get_rl_index(rl, last, run, level);
971
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
972
            if (code == rl->n) {
973
                int level1, run1;
974

    
975
                level1 = level - rl->max_level[last][run];
976
                if (level1 < 1) 
977
                    goto esc2;
978
                code = get_rl_index(rl, last, run, level1);
979
                if (code == rl->n) {
980
                esc2:
981
                    put_bits(&s->pb, 1, 0);
982
                    if (level > MAX_LEVEL)
983
                        goto esc3;
984
                    run1 = run - rl->max_run[last][level] - run_diff;
985
                    if (run1 < 0)
986
                        goto esc3;
987
                    code = get_rl_index(rl, last, run1, level);
988
                    if (code == rl->n) {
989
                    esc3:
990
                        /* third escape */
991
                        put_bits(&s->pb, 1, 0);
992
                        put_bits(&s->pb, 1, last);
993
                        if(s->msmpeg4_version>=4){
994
                            if(s->esc3_level_length==0){
995
                                s->esc3_level_length=8;
996
                                s->esc3_run_length= 6;
997
                                if(s->qscale<8)
998
                                    put_bits(&s->pb, 6, 3);
999
                                else
1000
                                    put_bits(&s->pb, 8, 3);
1001
                            }
1002
                            put_bits(&s->pb, s->esc3_run_length, run);
1003
                            put_bits(&s->pb, 1, sign);
1004
                            put_bits(&s->pb, s->esc3_level_length, level);
1005
                        }else{
1006
                            put_bits(&s->pb, 6, run);
1007
                            put_bits(&s->pb, 8, slevel & 0xff);
1008
                        }
1009
                    } else {
1010
                        /* second escape */
1011
                        put_bits(&s->pb, 1, 1);
1012
                        put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1013
                        put_bits(&s->pb, 1, sign);
1014
                    }
1015
                } else {
1016
                    /* first escape */
1017
                    put_bits(&s->pb, 1, 1);
1018
                    put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1019
                    put_bits(&s->pb, 1, sign);
1020
                }
1021
            } else {
1022
                put_bits(&s->pb, 1, sign);
1023
            }
1024
            last_non_zero = i;
1025
        }
1026
    }
1027
}
1028

    
1029
/****************************************/
1030
/* decoding stuff */
1031

    
1032
static VLC mb_non_intra_vlc[4];
1033
static VLC mb_intra_vlc;
1034
static VLC dc_lum_vlc[2];
1035
static VLC dc_chroma_vlc[2];
1036
static VLC v2_dc_lum_vlc;
1037
static VLC v2_dc_chroma_vlc;
1038
static VLC cbpy_vlc;
1039
static VLC v2_intra_cbpc_vlc;
1040
static VLC v2_mb_type_vlc;
1041
static VLC v2_mv_vlc;
1042
static VLC v1_intra_cbpc_vlc;
1043
static VLC v1_inter_cbpc_vlc;
1044
static VLC inter_intra_vlc;
1045

    
1046
/* this table is practically identical to the one from h263 except that its inverted */
1047
static void init_h263_dc_for_msmpeg4(void)
1048
{
1049
        int level, uni_code, uni_len;
1050

    
1051
        for(level=-256; level<256; level++){
1052
            int size, v, l;
1053
            /* find number of bits */
1054
            size = 0;
1055
            v = abs(level);
1056
            while (v) {
1057
                v >>= 1;
1058
                    size++;
1059
            }
1060

    
1061
            if (level < 0)
1062
                l= (-level) ^ ((1 << size) - 1);
1063
            else
1064
                l= level;
1065

    
1066
            /* luminance h263 */
1067
            uni_code= DCtab_lum[size][0];
1068
            uni_len = DCtab_lum[size][1];
1069
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1070

    
1071
            if (size > 0) {
1072
                uni_code<<=size; uni_code|=l;
1073
                uni_len+=size;
1074
                if (size > 8){
1075
                    uni_code<<=1; uni_code|=1;
1076
                    uni_len++;
1077
                }
1078
            }
1079
            v2_dc_lum_table[level+256][0]= uni_code;
1080
            v2_dc_lum_table[level+256][1]= uni_len;
1081

    
1082
            /* chrominance h263 */
1083
            uni_code= DCtab_chrom[size][0];
1084
            uni_len = DCtab_chrom[size][1];
1085
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1086
            
1087
            if (size > 0) {
1088
                uni_code<<=size; uni_code|=l;
1089
                uni_len+=size;
1090
                if (size > 8){
1091
                    uni_code<<=1; uni_code|=1;
1092
                    uni_len++;
1093
                }
1094
            }
1095
            v2_dc_chroma_table[level+256][0]= uni_code;
1096
            v2_dc_chroma_table[level+256][1]= uni_len;
1097

    
1098
        }
1099
}
1100

    
1101
/* init all vlc decoding tables */
1102
int ff_msmpeg4_decode_init(MpegEncContext *s)
1103
{
1104
    static int done = 0;
1105
    int i;
1106
    MVTable *mv;
1107

    
1108
    common_init(s);
1109

    
1110
    if (!done) {
1111
        done = 1;
1112

    
1113
        for(i=0;i<NB_RL_TABLES;i++) {
1114
            init_rl(&rl_table[i], 1);
1115
            init_vlc_rl(&rl_table[i], 1);
1116
        }
1117
        for(i=0;i<2;i++) {
1118
            mv = &mv_tables[i];
1119
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, 
1120
                     mv->table_mv_bits, 1, 1,
1121
                     mv->table_mv_code, 2, 2, 1);
1122
        }
1123

    
1124
        init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 
1125
                 &table0_dc_lum[0][1], 8, 4,
1126
                 &table0_dc_lum[0][0], 8, 4, 1);
1127
        init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1128
                 &table0_dc_chroma[0][1], 8, 4,
1129
                 &table0_dc_chroma[0][0], 8, 4, 1);
1130
        init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 
1131
                 &table1_dc_lum[0][1], 8, 4,
1132
                 &table1_dc_lum[0][0], 8, 4, 1);
1133
        init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1134
                 &table1_dc_chroma[0][1], 8, 4,
1135
                 &table1_dc_chroma[0][0], 8, 4, 1);
1136
    
1137
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 
1138
                 &v2_dc_lum_table[0][1], 8, 4,
1139
                 &v2_dc_lum_table[0][0], 8, 4, 1);
1140
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 
1141
                 &v2_dc_chroma_table[0][1], 8, 4,
1142
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
1143
    
1144
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1145
                 &cbpy_tab[0][1], 2, 1,
1146
                 &cbpy_tab[0][0], 2, 1, 1);
1147
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1148
                 &v2_intra_cbpc[0][1], 2, 1,
1149
                 &v2_intra_cbpc[0][0], 2, 1, 1);
1150
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1151
                 &v2_mb_type[0][1], 2, 1,
1152
                 &v2_mb_type[0][0], 2, 1, 1);
1153
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1154
                 &mvtab[0][1], 2, 1,
1155
                 &mvtab[0][0], 2, 1, 1);
1156

    
1157
        for(i=0; i<4; i++){
1158
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, 
1159
                     &wmv2_inter_table[i][0][1], 8, 4,
1160
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1161
        }
1162
        
1163
        init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64, 
1164
                 &table_mb_intra[0][1], 4, 2,
1165
                 &table_mb_intra[0][0], 4, 2, 1);
1166
        
1167
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, 
1168
                 intra_MCBPC_bits, 1, 1,
1169
                 intra_MCBPC_code, 1, 1, 1);
1170
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25, 
1171
                 inter_MCBPC_bits, 1, 1,
1172
                 inter_MCBPC_code, 1, 1, 1);
1173
        
1174
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 
1175
                 &table_inter_intra[0][1], 2, 1,
1176
                 &table_inter_intra[0][0], 2, 1, 1);
1177
    }
1178
    
1179
    switch(s->msmpeg4_version){
1180
    case 1:
1181
    case 2:
1182
        s->decode_mb= msmpeg4v12_decode_mb;
1183
        break;
1184
    case 3:
1185
    case 4:
1186
        s->decode_mb= msmpeg4v34_decode_mb;
1187
        break;
1188
    case 5:
1189
        s->decode_mb= wmv2_decode_mb;
1190
        break;
1191
    }
1192
    
1193
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1194
    
1195
    return 0;
1196
}
1197

    
1198
static int decode012(GetBitContext *gb)
1199
{
1200
    int n;
1201
    n = get_bits1(gb);
1202
    if (n == 0)
1203
        return 0;
1204
    else
1205
        return get_bits1(gb) + 1;
1206
}
1207

    
1208
int msmpeg4_decode_picture_header(MpegEncContext * s)
1209
{
1210
    int code;
1211

    
1212
#if 0
1213
{
1214
int i;
1215
for(i=0; i<s->gb.size_in_bits; i++)
1216
    printf("%d", get_bits1(&s->gb));
1217
//    get_bits1(&s->gb);
1218
printf("END\n");
1219
return -1;
1220
}
1221
#endif
1222

    
1223
    if(s->msmpeg4_version==1){
1224
        int start_code, num;
1225
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1226
        if(start_code!=0x00000100){
1227
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1228
            return -1;
1229
        }
1230

    
1231
        num= get_bits(&s->gb, 5); // frame number */
1232
    }
1233

    
1234
    s->pict_type = get_bits(&s->gb, 2) + 1;
1235
    if (s->pict_type != I_TYPE &&
1236
        s->pict_type != P_TYPE){
1237
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1238
        return -1;
1239
    }
1240
#if 0
1241
{
1242
    static int had_i=0;
1243
    if(s->pict_type == I_TYPE) had_i=1;
1244
    if(!had_i) return -1;
1245
}
1246
#endif
1247
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1248
    if(s->qscale==0){
1249
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1250
        return -1;
1251
    }
1252

    
1253
    if (s->pict_type == I_TYPE) {
1254
        code = get_bits(&s->gb, 5); 
1255
        if(s->msmpeg4_version==1){
1256
            if(code==0 || code>s->mb_height){
1257
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1258
                return -1;
1259
            }
1260

    
1261
            s->slice_height = code;
1262
        }else{
1263
            /* 0x17: one slice, 0x18: two slices, ... */
1264
            if (code < 0x17){
1265
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1266
                return -1;
1267
            }
1268

    
1269
            s->slice_height = s->mb_height / (code - 0x16);
1270
        }
1271

    
1272
        switch(s->msmpeg4_version){
1273
        case 1:
1274
        case 2:
1275
            s->rl_chroma_table_index = 2;
1276
            s->rl_table_index = 2;
1277

    
1278
            s->dc_table_index = 0; //not used
1279
            break;
1280
        case 3:
1281
            s->rl_chroma_table_index = decode012(&s->gb);
1282
            s->rl_table_index = decode012(&s->gb);
1283

    
1284
            s->dc_table_index = get_bits1(&s->gb);
1285
            break;
1286
        case 4:
1287
            msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1288

    
1289
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1290
            else                           s->per_mb_rl_table= 0;
1291
            
1292
            if(!s->per_mb_rl_table){
1293
                s->rl_chroma_table_index = decode012(&s->gb);
1294
                s->rl_table_index = decode012(&s->gb);
1295
            }
1296

    
1297
            s->dc_table_index = get_bits1(&s->gb);
1298
            s->inter_intra_pred= 0;
1299
            break;
1300
        }
1301
        s->no_rounding = 1;
1302
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1303
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n", 
1304
                s->qscale,
1305
                s->rl_chroma_table_index,
1306
                s->rl_table_index, 
1307
                s->dc_table_index,
1308
                s->per_mb_rl_table,
1309
                s->slice_height);
1310
    } else {
1311
        switch(s->msmpeg4_version){
1312
        case 1:
1313
        case 2:
1314
            if(s->msmpeg4_version==1)
1315
                s->use_skip_mb_code = 1;
1316
            else
1317
                s->use_skip_mb_code = get_bits1(&s->gb);
1318
            s->rl_table_index = 2;
1319
            s->rl_chroma_table_index = s->rl_table_index;
1320
            s->dc_table_index = 0; //not used
1321
            s->mv_table_index = 0;
1322
            break;
1323
        case 3:
1324
            s->use_skip_mb_code = get_bits1(&s->gb);
1325
            s->rl_table_index = decode012(&s->gb);
1326
            s->rl_chroma_table_index = s->rl_table_index;
1327

    
1328
            s->dc_table_index = get_bits1(&s->gb);
1329

    
1330
            s->mv_table_index = get_bits1(&s->gb);
1331
            break;
1332
        case 4:
1333
            s->use_skip_mb_code = get_bits1(&s->gb);
1334

    
1335
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1336
            else                           s->per_mb_rl_table= 0;
1337

    
1338
            if(!s->per_mb_rl_table){
1339
                s->rl_table_index = decode012(&s->gb);
1340
                s->rl_chroma_table_index = s->rl_table_index;
1341
            }
1342

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

    
1345
            s->mv_table_index = get_bits1(&s->gb);
1346
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1347
            break;
1348
        }
1349
        
1350
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1351
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n", 
1352
                s->use_skip_mb_code, 
1353
                s->rl_table_index, 
1354
                s->rl_chroma_table_index, 
1355
                s->dc_table_index,
1356
                s->mv_table_index,
1357
                s->per_mb_rl_table,
1358
                s->qscale);
1359

    
1360
        if(s->flipflop_rounding){
1361
            s->no_rounding ^= 1;
1362
        }else{
1363
            s->no_rounding = 0;
1364
        }
1365
    }
1366
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1367

    
1368
    s->esc3_level_length= 0;
1369
    s->esc3_run_length= 0;
1370

    
1371
#ifdef DEBUG
1372
    printf("*****frame %d:\n", frame_count++);
1373
#endif
1374
    return 0;
1375
}
1376

    
1377
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1378
{
1379
    int left= buf_size*8 - get_bits_count(&s->gb);
1380
    int length= s->msmpeg4_version>=3 ? 17 : 16;
1381
    /* the alt_bitstream reader could read over the end so we need to check it */
1382
    if(left>=length && left<length+8)
1383
    {
1384
        int fps;
1385

    
1386
        fps= get_bits(&s->gb, 5);
1387
        s->bit_rate= get_bits(&s->gb, 11)*1024;
1388
        if(s->msmpeg4_version>=3)
1389
            s->flipflop_rounding= get_bits1(&s->gb);
1390
        else
1391
            s->flipflop_rounding= 0;
1392

    
1393
//        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1394
    }
1395
    else if(left<length+8)
1396
    {
1397
        s->flipflop_rounding= 0;
1398
        if(s->msmpeg4_version != 2)
1399
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1400
    }
1401
    else
1402
    {
1403
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1404
    }
1405

    
1406
    return 0;
1407
}
1408

    
1409
static inline void msmpeg4_memsetw(short *tab, int val, int n)
1410
{
1411
    int i;
1412
    for(i=0;i<n;i++)
1413
        tab[i] = val;
1414
}
1415

    
1416
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1417
{
1418
    int range, bit_size, sign, code, bits;
1419

    
1420
    if (val == 0) {
1421
        /* zero vector */
1422
        code = 0;
1423
        put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1424
    } else {
1425
        bit_size = s->f_code - 1;
1426
        range = 1 << bit_size;
1427
        if (val <= -64)
1428
            val += 64;
1429
        else if (val >= 64)
1430
            val -= 64;
1431

    
1432
        if (val >= 0) {
1433
            sign = 0;
1434
        } else {
1435
            val = -val;
1436
            sign = 1;
1437
        }
1438
        val--;
1439
        code = (val >> bit_size) + 1;
1440
        bits = val & (range - 1);
1441

    
1442
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
1443
        if (bit_size > 0) {
1444
            put_bits(&s->pb, bit_size, bits);
1445
        }
1446
    }
1447
}
1448

    
1449
/* this is identical to h263 except that its range is multiplied by 2 */
1450
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1451
{
1452
    int code, val, sign, shift;
1453

    
1454
    code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1455
//     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1456
    if (code < 0)
1457
        return 0xffff;
1458

    
1459
    if (code == 0)
1460
        return pred;
1461
    sign = get_bits1(&s->gb);
1462
    shift = f_code - 1;
1463
    val = code;
1464
    if (shift) {
1465
        val = (val - 1) << shift;
1466
        val |= get_bits(&s->gb, shift);
1467
        val++;
1468
    }
1469
    if (sign)
1470
        val = -val;
1471

    
1472
    val += pred;
1473
    if (val <= -64)
1474
        val += 64;
1475
    else if (val >= 64)
1476
        val -= 64;
1477

    
1478
    return val;
1479
}
1480

    
1481
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1482
{
1483
    int cbp, code, i;
1484
    
1485
    if (s->pict_type == P_TYPE) {
1486
        if (s->use_skip_mb_code) {
1487
            if (get_bits1(&s->gb)) {
1488
                /* skip mb */
1489
                s->mb_intra = 0;
1490
                for(i=0;i<6;i++)
1491
                    s->block_last_index[i] = -1;
1492
                s->mv_dir = MV_DIR_FORWARD;
1493
                s->mv_type = MV_TYPE_16X16;
1494
                s->mv[0][0][0] = 0;
1495
                s->mv[0][0][1] = 0;
1496
                s->mb_skiped = 1;
1497
                return 0;
1498
            }
1499
        }
1500

    
1501
        if(s->msmpeg4_version==2)
1502
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1503
        else
1504
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1505
        if(code<0 || code>7){
1506
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1507
            return -1;
1508
        }
1509

    
1510
        s->mb_intra = code >>2;
1511
    
1512
        cbp = code & 0x3;
1513
    } else {
1514
        s->mb_intra = 1;
1515
        if(s->msmpeg4_version==2)
1516
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1517
        else
1518
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1519
        if(cbp<0 || cbp>3){
1520
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1521
            return -1;
1522
        }
1523
    }
1524

    
1525
    if (!s->mb_intra) {
1526
        int mx, my, cbpy;
1527
        
1528
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1529
        if(cbpy<0){
1530
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1531
            return -1;
1532
        }
1533

    
1534
        cbp|= cbpy<<2;
1535
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1536
        
1537
        h263_pred_motion(s, 0, 0, &mx, &my);
1538
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1539
        my= msmpeg4v2_decode_motion(s, my, 1);
1540
        
1541
        s->mv_dir = MV_DIR_FORWARD;
1542
        s->mv_type = MV_TYPE_16X16;
1543
        s->mv[0][0][0] = mx;
1544
        s->mv[0][0][1] = my;
1545
    } else {
1546
        if(s->msmpeg4_version==2){
1547
            s->ac_pred = get_bits1(&s->gb);
1548
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1549
        } else{
1550
            s->ac_pred = 0;
1551
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1552
            if(s->pict_type==P_TYPE) cbp^=0x3C;
1553
        }
1554
    }
1555

    
1556
    for (i = 0; i < 6; i++) {
1557
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1558
        {
1559
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1560
             return -1;
1561
        }
1562
    }
1563
    return 0;
1564
}
1565

    
1566
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1567
{
1568
    int cbp, code, i;
1569
    uint8_t *coded_val;
1570
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1571

    
1572
    if (s->pict_type == P_TYPE) {
1573
        set_stat(ST_INTER_MB);
1574
        if (s->use_skip_mb_code) {
1575
            if (get_bits1(&s->gb)) {
1576
                /* skip mb */
1577
                s->mb_intra = 0;
1578
                for(i=0;i<6;i++)
1579
                    s->block_last_index[i] = -1;
1580
                s->mv_dir = MV_DIR_FORWARD;
1581
                s->mv_type = MV_TYPE_16X16;
1582
                s->mv[0][0][0] = 0;
1583
                s->mv[0][0][1] = 0;
1584
                s->mb_skiped = 1;
1585
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1586

    
1587
                return 0;
1588
            }
1589
        }
1590
        
1591
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1592
        if (code < 0)
1593
            return -1;
1594
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1595
        s->mb_intra = (~code & 0x40) >> 6;
1596
            
1597
        cbp = code & 0x3f;
1598
    } else {
1599
        set_stat(ST_INTRA_MB);
1600
        s->mb_intra = 1;
1601
        code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1602
        if (code < 0)
1603
            return -1;
1604
        /* predict coded block pattern */
1605
        cbp = 0;
1606
        for(i=0;i<6;i++) {
1607
            int val = ((code >> (5 - i)) & 1);
1608
            if (i < 4) {
1609
                int pred = coded_block_pred(s, i, &coded_val);
1610
                val = val ^ pred;
1611
                *coded_val = val;
1612
            }
1613
            cbp |= val << (5 - i);
1614
        }
1615
    }
1616

    
1617
    if (!s->mb_intra) {
1618
        int mx, my;
1619
//printf("P at %d %d\n", s->mb_x, s->mb_y);
1620
        if(s->per_mb_rl_table && cbp){
1621
            s->rl_table_index = decode012(&s->gb);
1622
            s->rl_chroma_table_index = s->rl_table_index;
1623
        }
1624
        set_stat(ST_MV);
1625
        h263_pred_motion(s, 0, 0, &mx, &my);
1626
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1627
            return -1;
1628
        s->mv_dir = MV_DIR_FORWARD;
1629
        s->mv_type = MV_TYPE_16X16;
1630
        s->mv[0][0][0] = mx;
1631
        s->mv[0][0][1] = my;
1632
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1633
    } else {
1634
//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));
1635
        set_stat(ST_INTRA_MB);
1636
        s->ac_pred = get_bits1(&s->gb);
1637
        *mb_type_ptr = MB_TYPE_INTRA;
1638
        if(s->inter_intra_pred){
1639
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1640
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1641
        }
1642
        if(s->per_mb_rl_table && cbp){
1643
            s->rl_table_index = decode012(&s->gb);
1644
            s->rl_chroma_table_index = s->rl_table_index;
1645
        }
1646
    }
1647

    
1648
    for (i = 0; i < 6; i++) {
1649
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1650
        {
1651
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1652
            return -1;
1653
        }
1654
    }
1655
    
1656
    return 0;
1657
}
1658
//#define ERROR_DETAILS
1659
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1660
                              int n, int coded, const uint8_t *scan_table)
1661
{
1662
    int level, i, last, run, run_diff;
1663
    int dc_pred_dir;
1664
    RLTable *rl;
1665
    RL_VLC_ELEM *rl_vlc;
1666
    int qmul, qadd;
1667

    
1668
    if (s->mb_intra) {
1669
        qmul=1;
1670
        qadd=0;
1671

    
1672
        /* DC coef */
1673
        set_stat(ST_DC);
1674
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1675
        
1676
        if (level < 0){
1677
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1678
            if(s->inter_intra_pred) level=0;
1679
            else                    return -1;
1680
        }
1681
        if (n < 4) {
1682
            rl = &rl_table[s->rl_table_index];
1683
            if(level > 256*s->y_dc_scale){
1684
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1685
                if(!s->inter_intra_pred) return -1;
1686
            }
1687
        } else {
1688
            rl = &rl_table[3 + s->rl_chroma_table_index];
1689
            if(level > 256*s->c_dc_scale){
1690
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1691
                if(!s->inter_intra_pred) return -1;
1692
            }
1693
        }
1694
        block[0] = level;
1695

    
1696
        run_diff = 0;
1697
        i = 0;
1698
        if (!coded) {
1699
            goto not_coded;
1700
        }
1701
        if (s->ac_pred) {
1702
            if (dc_pred_dir == 0) 
1703
                scan_table = s->intra_v_scantable.permutated; /* left */
1704
            else
1705
                scan_table = s->intra_h_scantable.permutated; /* top */
1706
        } else {
1707
            scan_table = s->intra_scantable.permutated;
1708
        }
1709
        set_stat(ST_INTRA_AC);
1710
        rl_vlc= rl->rl_vlc[0];
1711
    } else {
1712
        qmul = s->qscale << 1;
1713
        qadd = (s->qscale - 1) | 1;
1714
        i = -1;
1715
        rl = &rl_table[3 + s->rl_table_index];
1716

    
1717
        if(s->msmpeg4_version==2)
1718
            run_diff = 0;
1719
        else
1720
            run_diff = 1;
1721

    
1722
        if (!coded) {
1723
            s->block_last_index[n] = i;
1724
            return 0;
1725
        }
1726
        if(!scan_table)
1727
            scan_table = s->inter_scantable.permutated;
1728
        set_stat(ST_INTER_AC);
1729
        rl_vlc= rl->rl_vlc[s->qscale];
1730
    }
1731
  {
1732
    OPEN_READER(re, &s->gb);
1733
    for(;;) {
1734
        UPDATE_CACHE(re, &s->gb);
1735
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1736
        if (level==0) {
1737
            int cache;
1738
            cache= GET_CACHE(re, &s->gb);
1739
            /* escape */
1740
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1741
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1742
                    /* third escape */
1743
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1744
                    UPDATE_CACHE(re, &s->gb);
1745
                    if(s->msmpeg4_version<=3){
1746
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1747
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1748
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1749
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
1750
                    }else{                        
1751
                        int sign;
1752
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1753
                        if(!s->esc3_level_length){
1754
                            int ll;
1755
                            //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1756
                            if(s->qscale<8){
1757
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1758
                                if(ll==0){
1759
                                    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");
1760
                                    SKIP_BITS(re, &s->gb, 1);
1761
                                    ll=8;
1762
                                }
1763
                            }else{
1764
                                ll=2;
1765
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1766
                                    ll++;
1767
                                    SKIP_BITS(re, &s->gb, 1);
1768
                                }
1769
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
1770
                            }
1771

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

    
1888
            block[scan_table[i]] = level;
1889
            break;
1890
        }
1891

    
1892
        block[scan_table[i]] = level;
1893
    }
1894
    CLOSE_READER(re, &s->gb);
1895
  }
1896
 not_coded:
1897
    if (s->mb_intra) {
1898
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1899
        if (s->ac_pred) {
1900
            i = 63; /* XXX: not optimal */
1901
        }
1902
    }
1903
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1904
    s->block_last_index[n] = i;
1905
    
1906
    return 0;
1907
}
1908

    
1909
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1910
{
1911
    int level, pred;
1912

    
1913
    if(s->msmpeg4_version<=2){
1914
        if (n < 4) {
1915
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1916
        } else {
1917
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1918
        }
1919
        if (level < 0) 
1920
            return -1;
1921
        level-=256;
1922
    }else{  //FIXME optimize use unified tables & index
1923
        if (n < 4) {
1924
            level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1925
        } else {
1926
            level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1927
        }
1928
        if (level < 0){
1929
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1930
            return -1;
1931
        }
1932

    
1933
        if (level == DC_MAX) {
1934
            level = get_bits(&s->gb, 8);
1935
            if (get_bits1(&s->gb))
1936
                level = -level;
1937
        } else if (level != 0) {
1938
            if (get_bits1(&s->gb))
1939
                level = -level;
1940
        }
1941
    }
1942

    
1943
    if(s->msmpeg4_version==1){
1944
        int32_t *dc_val;
1945
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1946
        level += pred;
1947
        
1948
        /* update predictor */
1949
        *dc_val= level;
1950
    }else{
1951
        uint16_t *dc_val;
1952
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1953
        level += pred;
1954

    
1955
        /* update predictor */
1956
        if (n < 4) {
1957
            *dc_val = level * s->y_dc_scale;
1958
        } else {
1959
            *dc_val = level * s->c_dc_scale;
1960
        }
1961
    }
1962

    
1963
    return level;
1964
}
1965

    
1966
static int msmpeg4_decode_motion(MpegEncContext * s, 
1967
                                 int *mx_ptr, int *my_ptr)
1968
{
1969
    MVTable *mv;
1970
    int code, mx, my;
1971

    
1972
    mv = &mv_tables[s->mv_table_index];
1973

    
1974
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1975
    if (code < 0){
1976
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1977
        return -1;
1978
    }
1979
    if (code == mv->n) {
1980
//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1981
        mx = get_bits(&s->gb, 6);
1982
        my = get_bits(&s->gb, 6);
1983
    } else {
1984
        mx = mv->table_mvx[code];
1985
        my = mv->table_mvy[code];
1986
    }
1987

    
1988
    mx += *mx_ptr - 32;
1989
    my += *my_ptr - 32;
1990
    /* WARNING : they do not do exactly modulo encoding */
1991
    if (mx <= -64)
1992
        mx += 64;
1993
    else if (mx >= 64)
1994
        mx -= 64;
1995

    
1996
    if (my <= -64)
1997
        my += 64;
1998
    else if (my >= 64)
1999
        my -= 64;
2000
    *mx_ptr = mx;
2001
    *my_ptr = my;
2002
    return 0;
2003
}
2004

    
2005
/* cleanest way to support it
2006
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2007
 * as allmost everything would be in the common file 
2008
 */
2009
#include "wmv2.c"