Statistics
| Branch: | Revision:

ffmpeg / libavcodec / msmpeg4.c @ e91f4bf1

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
/* vc9 externs */
79
extern uint8_t wmv3_dc_scale_table[32];
80

    
81
#ifdef DEBUG
82
int intra_count = 0;
83
int frame_count = 0;
84
#endif
85

    
86
#include "msmpeg4data.h"
87

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

    
92
#ifdef STATS
93

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

    
104
int st_current_index = 0;
105
unsigned int st_bit_counts[ST_NB];
106
unsigned int st_out_bit_counts[ST_NB];
107

    
108
#define set_stat(var) st_current_index = var;
109

    
110
void print_stats(void)
111
{
112
    unsigned int total;
113
    int i;
114

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

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

    
150
#else
151

    
152
#define set_stat(var)
153

    
154
#endif
155

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

    
185
    }
186

    
187
    
188
    if(s->msmpeg4_version>=4){
189
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
190
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
191
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]);
192
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
193
    }
194
    //Note the default tables are set in common_init in mpegvideo.c
195
    
196
    if(!inited){
197
        inited=1;
198

    
199
        init_h263_dc_for_msmpeg4();
200
    }
201
}
202

    
203
#ifdef CONFIG_ENCODERS
204

    
205
/* build the table which associate a (x,y) motion vector to a vlc */
206
static void init_mv_table(MVTable *tab)
207
{
208
    int i, x, y;
209

    
210
    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
211
    /* mark all entries as not used */
212
    for(i=0;i<4096;i++)
213
        tab->table_mv_index[i] = tab->n;
214
    
215
    for(i=0;i<tab->n;i++) {
216
        x = tab->table_mvx[i];
217
        y = tab->table_mvy[i];
218
        tab->table_mv_index[(x << 6) | y] = i;
219
    }
220
}
221

    
222
static void code012(PutBitContext *pb, int n)
223
{
224
    if (n == 0) {
225
        put_bits(pb, 1, 0);
226
    } else {
227
        put_bits(pb, 1, 1);
228
        put_bits(pb, 1, (n >= 2));
229
    }
230
}
231

    
232
void ff_msmpeg4_encode_init(MpegEncContext *s)
233
{
234
    static int init_done=0;
235
    int i;
236

    
237
    common_init(s);
238
    if(s->msmpeg4_version>=4){
239
        s->min_qcoeff= -255;
240
        s->max_qcoeff=  255;
241
    }
242

    
243
    if (!init_done) {
244
        /* init various encoding tables */
245
        init_done = 1;
246
        init_mv_table(&mv_tables[0]);
247
        init_mv_table(&mv_tables[1]);
248
        for(i=0;i<NB_RL_TABLES;i++)
249
            init_rl(&rl_table[i], 1);
250

    
251
        for(i=0; i<NB_RL_TABLES; i++){
252
            int level;
253
            for(level=0; level<=MAX_LEVEL; level++){
254
                int run;
255
                for(run=0; run<=MAX_RUN; run++){
256
                    int last;
257
                    for(last=0; last<2; last++){
258
                        rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
259
                    }
260
                }
261
            }
262
        }
263
    }
264
}
265

    
266
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
267
    int size=0;
268
    int code;
269
    int run_diff= intra ? 0 : 1;
270
    
271
    code = get_rl_index(rl, last, run, level);
272
    size+= rl->table_vlc[code][1];
273
    if (code == rl->n) {
274
        int level1, run1;
275

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

    
307
static void find_best_tables(MpegEncContext * s)
308
{
309
    int i;
310
    int best       =-1, best_size       =9999999;
311
    int chroma_best=-1, best_chroma_size=9999999;
312

    
313
    for(i=0; i<3; i++){
314
        int level;
315
        int chroma_size=0;
316
        int size=0;
317

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

    
354
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", 
355
//           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
356
           
357
    if(s->pict_type==P_TYPE) chroma_best= best;
358

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

    
361
    s->rl_table_index       =        best;
362
    s->rl_chroma_table_index= chroma_best;
363
    
364
    if(s->pict_type != s->last_non_b_pict_type){
365
        s->rl_table_index= 2;
366
        if(s->pict_type==I_TYPE)
367
            s->rl_chroma_table_index= 1;
368
        else
369
            s->rl_chroma_table_index= 2;
370
    }
371

    
372
}
373

    
374
/* write MSMPEG4 compatible frame header */
375
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
376
{
377
    find_best_tables(s);
378

    
379
    align_put_bits(&s->pb);
380
    put_bits(&s->pb, 2, s->pict_type - 1);
381

    
382
    put_bits(&s->pb, 5, s->qscale);
383
    if(s->msmpeg4_version<=2){
384
        s->rl_table_index = 2;
385
        s->rl_chroma_table_index = 2;
386
    }
387

    
388
    s->dc_table_index = 1;
389
    s->mv_table_index = 1; /* only if P frame */
390
    s->use_skip_mb_code = 1; /* only if P frame */
391
    s->per_mb_rl_table = 0;
392
    if(s->msmpeg4_version==4)
393
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
394
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
395

    
396
    if (s->pict_type == I_TYPE) {
397
        s->slice_height= s->mb_height/1;
398
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
399
        
400
        if(s->msmpeg4_version==4){
401
            msmpeg4_encode_ext_header(s);
402
            if(s->bit_rate>MBAC_BITRATE)
403
                put_bits(&s->pb, 1, s->per_mb_rl_table);
404
        }
405

    
406
        if(s->msmpeg4_version>2){
407
            if(!s->per_mb_rl_table){
408
                code012(&s->pb, s->rl_chroma_table_index);
409
                code012(&s->pb, s->rl_table_index);
410
            }
411

    
412
            put_bits(&s->pb, 1, s->dc_table_index);
413
        }
414
    } else {
415
        put_bits(&s->pb, 1, s->use_skip_mb_code);
416
        
417
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
418
            put_bits(&s->pb, 1, s->per_mb_rl_table);
419

    
420
        if(s->msmpeg4_version>2){
421
            if(!s->per_mb_rl_table)
422
                code012(&s->pb, s->rl_table_index);
423

    
424
            put_bits(&s->pb, 1, s->dc_table_index);
425

    
426
            put_bits(&s->pb, 1, s->mv_table_index);
427
        }
428
    }
429

    
430
    s->esc3_level_length= 0;
431
    s->esc3_run_length= 0;
432

    
433
#ifdef DEBUG
434
    intra_count = 0;
435
    printf("*****frame %d:\n", frame_count++);
436
#endif
437
}
438

    
439
void msmpeg4_encode_ext_header(MpegEncContext * s)
440
{
441
        put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
442

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

    
445
        if(s->msmpeg4_version>=3)
446
            put_bits(&s->pb, 1, s->flipflop_rounding);
447
        else
448
            assert(s->flipflop_rounding==0);
449
}
450

    
451
#endif //CONFIG_ENCODERS
452

    
453
/* predict coded block */
454
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
455
{
456
    int xy, wrap, pred, a, b, c;
457

    
458
    xy = s->block_index[n];
459
    wrap = s->b8_stride;
460

    
461
    /* B C
462
     * A X 
463
     */
464
    a = s->coded_block[xy - 1       ];
465
    b = s->coded_block[xy - 1 - wrap];
466
    c = s->coded_block[xy     - wrap];
467
    
468
    if (b == c) {
469
        pred = a;
470
    } else {
471
        pred = c;
472
    }
473
    
474
    /* store value */
475
    *coded_block_ptr = &s->coded_block[xy];
476

    
477
    return pred;
478
}
479

    
480
#ifdef CONFIG_ENCODERS
481

    
482
static void msmpeg4_encode_motion(MpegEncContext * s, 
483
                                  int mx, int my)
484
{
485
    int code;
486
    MVTable *mv;
487

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

    
509
    code = mv->table_mv_index[(mx << 6) | my];
510
    set_stat(ST_MV);
511
    put_bits(&s->pb, 
512
             mv->table_mv_bits[code], 
513
             mv->table_mv_code[code]);
514
    if (code == mv->n) {
515
        /* escape : code litterally */
516
        put_bits(&s->pb, 6, mx);
517
        put_bits(&s->pb, 6, my);
518
    }
519
}
520

    
521
static inline void handle_slices(MpegEncContext *s){
522
    if (s->mb_x == 0) {
523
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
524
            if(s->msmpeg4_version < 4){
525
                ff_mpeg4_clean_buffers(s);
526
            }
527
            s->first_slice_line = 1;
528
        } else {
529
            s->first_slice_line = 0; 
530
        }
531
    }
532
}
533

    
534
void msmpeg4_encode_mb(MpegEncContext * s, 
535
                       DCTELEM block[6][64],
536
                       int motion_x, int motion_y)
537
{
538
    int cbp, coded_cbp, i;
539
    int pred_x, pred_y;
540
    uint8_t *coded_block;
541

    
542
    handle_slices(s);
543
    
544
    if (!s->mb_intra) {
545
        /* compute cbp */
546
        set_stat(ST_INTER_MB);
547
        cbp = 0;
548
        for (i = 0; i < 6; i++) {
549
            if (s->block_last_index[i] >= 0)
550
                cbp |= 1 << (5 - i);
551
        }
552
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
553
            /* skip macroblock */
554
            put_bits(&s->pb, 1, 1);
555
            s->last_bits++;
556
            s->misc_bits++;
557
            s->skip_count++;
558

    
559
            return;
560
        }
561
        if (s->use_skip_mb_code)
562
            put_bits(&s->pb, 1, 0);        /* mb coded */
563
        
564
        if(s->msmpeg4_version<=2){
565
            put_bits(&s->pb, 
566
                     v2_mb_type[cbp&3][1], 
567
                     v2_mb_type[cbp&3][0]);
568
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
569
            else             coded_cbp= cbp;
570

    
571
            put_bits(&s->pb, 
572
                     cbpy_tab[coded_cbp>>2][1], 
573
                     cbpy_tab[coded_cbp>>2][0]);
574

    
575
            s->misc_bits += get_bits_diff(s);
576

    
577
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
578
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
579
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
580
        }else{
581
            put_bits(&s->pb, 
582
                     table_mb_non_intra[cbp + 64][1], 
583
                     table_mb_non_intra[cbp + 64][0]);
584

    
585
            s->misc_bits += get_bits_diff(s);
586

    
587
            /* motion vector */
588
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
589
            msmpeg4_encode_motion(s, motion_x - pred_x, 
590
                                  motion_y - pred_y);
591
        }
592

    
593
        s->mv_bits += get_bits_diff(s);
594

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

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

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

    
664
#endif //CONFIG_ENCODERS
665

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

    
671
    if (n < 4) {
672
        i= 0;
673
    } else {
674
        i= n-3;
675
    }
676
    
677
    *dc_val_ptr= &s->last_dc[i];
678
    return s->last_dc[i]; 
679
}
680

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

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

    
701
    /* find prediction */
702
    if (n < 4) {
703
        scale = s->y_dc_scale;
704
    } else {
705
        scale = s->c_dc_scale;
706
    }
707
    
708
    wrap = s->block_wrap[n];
709
    dc_val= s->dc_val[0] + s->block_index[n];
710

    
711
    /* B C
712
     * A X 
713
     */
714
    a = dc_val[ - 1];
715
    b = dc_val[ - 1 - wrap];
716
    c = dc_val[ - wrap];
717
    
718
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
719
        b=c=1024;
720
    }
721

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

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

    
842
#define DC_MAX 119
843

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

    
849
    if(s->msmpeg4_version==1){
850
        int32_t *dc_val;
851
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
852
        
853
        /* update predictor */
854
        *dc_val= level;
855
    }else{
856
        uint16_t *dc_val;
857
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
858

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

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

    
870
    if(s->msmpeg4_version<=2){
871
        if (n < 4) {
872
            put_bits(&s->pb, 
873
                     v2_dc_lum_table[level+256][1],
874
                     v2_dc_lum_table[level+256][0]);
875
        }else{
876
            put_bits(&s->pb, 
877
                     v2_dc_chroma_table[level+256][1],
878
                     v2_dc_chroma_table[level+256][0]);
879
        }
880
    }else{
881
        sign = 0;
882
        if (level < 0) {
883
            level = -level;
884
            sign = 1;
885
        }
886
        code = level;
887
        if (code > DC_MAX) 
888
            code = DC_MAX;
889

    
890
        if (s->dc_table_index == 0) {
891
            if (n < 4) {
892
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
893
            } else {
894
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
895
            }
896
        } else {
897
            if (n < 4) {
898
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
899
            } else {
900
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
901
            }
902
        }
903
            
904
        if (code == DC_MAX)
905
            put_bits(&s->pb, 8, level);
906
            
907
        if (level != 0) {
908
            put_bits(&s->pb, 1, sign);
909
        }
910
    }
911
}
912

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

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

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

    
970
            if(level<=MAX_LEVEL && run<=MAX_RUN){
971
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
972
            }
973
#if 0
974
else
975
    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
976
#endif
977
            code = get_rl_index(rl, last, run, level);
978
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
979
            if (code == rl->n) {
980
                int level1, run1;
981

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

    
1036
/****************************************/
1037
/* decoding stuff */
1038

    
1039
static VLC mb_non_intra_vlc[4];
1040
VLC ff_msmp4_mb_i_vlc;
1041
VLC ff_msmp4_dc_luma_vlc[2];
1042
VLC ff_msmp4_dc_chroma_vlc[2];
1043
static VLC v2_dc_lum_vlc;
1044
static VLC v2_dc_chroma_vlc;
1045
static VLC cbpy_vlc;
1046
static VLC v2_intra_cbpc_vlc;
1047
static VLC v2_mb_type_vlc;
1048
static VLC v2_mv_vlc;
1049
static VLC v1_intra_cbpc_vlc;
1050
static VLC v1_inter_cbpc_vlc;
1051
static VLC inter_intra_vlc;
1052

    
1053
/* this table is practically identical to the one from h263 except that its inverted */
1054
static void init_h263_dc_for_msmpeg4(void)
1055
{
1056
        int level, uni_code, uni_len;
1057

    
1058
        for(level=-256; level<256; level++){
1059
            int size, v, l;
1060
            /* find number of bits */
1061
            size = 0;
1062
            v = abs(level);
1063
            while (v) {
1064
                v >>= 1;
1065
                    size++;
1066
            }
1067

    
1068
            if (level < 0)
1069
                l= (-level) ^ ((1 << size) - 1);
1070
            else
1071
                l= level;
1072

    
1073
            /* luminance h263 */
1074
            uni_code= DCtab_lum[size][0];
1075
            uni_len = DCtab_lum[size][1];
1076
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1077

    
1078
            if (size > 0) {
1079
                uni_code<<=size; uni_code|=l;
1080
                uni_len+=size;
1081
                if (size > 8){
1082
                    uni_code<<=1; uni_code|=1;
1083
                    uni_len++;
1084
                }
1085
            }
1086
            v2_dc_lum_table[level+256][0]= uni_code;
1087
            v2_dc_lum_table[level+256][1]= uni_len;
1088

    
1089
            /* chrominance h263 */
1090
            uni_code= DCtab_chrom[size][0];
1091
            uni_len = DCtab_chrom[size][1];
1092
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1093
            
1094
            if (size > 0) {
1095
                uni_code<<=size; uni_code|=l;
1096
                uni_len+=size;
1097
                if (size > 8){
1098
                    uni_code<<=1; uni_code|=1;
1099
                    uni_len++;
1100
                }
1101
            }
1102
            v2_dc_chroma_table[level+256][0]= uni_code;
1103
            v2_dc_chroma_table[level+256][1]= uni_len;
1104

    
1105
        }
1106
}
1107

    
1108
/* init all vlc decoding tables */
1109
int ff_msmpeg4_decode_init(MpegEncContext *s)
1110
{
1111
    static int done = 0;
1112
    int i;
1113
    MVTable *mv;
1114

    
1115
    common_init(s);
1116

    
1117
    if (!done) {
1118
        done = 1;
1119

    
1120
        for(i=0;i<NB_RL_TABLES;i++) {
1121
            init_rl(&rl_table[i], 1);
1122
            init_vlc_rl(&rl_table[i], 1);
1123
        }
1124
        for(i=0;i<2;i++) {
1125
            mv = &mv_tables[i];
1126
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, 
1127
                     mv->table_mv_bits, 1, 1,
1128
                     mv->table_mv_code, 2, 2, 1);
1129
        }
1130

    
1131
        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 
1132
                 &ff_table0_dc_lum[0][1], 8, 4,
1133
                 &ff_table0_dc_lum[0][0], 8, 4, 1);
1134
        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1135
                 &ff_table0_dc_chroma[0][1], 8, 4,
1136
                 &ff_table0_dc_chroma[0][0], 8, 4, 1);
1137
        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 
1138
                 &ff_table1_dc_lum[0][1], 8, 4,
1139
                 &ff_table1_dc_lum[0][0], 8, 4, 1);
1140
        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1141
                 &ff_table1_dc_chroma[0][1], 8, 4,
1142
                 &ff_table1_dc_chroma[0][0], 8, 4, 1);
1143
    
1144
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 
1145
                 &v2_dc_lum_table[0][1], 8, 4,
1146
                 &v2_dc_lum_table[0][0], 8, 4, 1);
1147
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 
1148
                 &v2_dc_chroma_table[0][1], 8, 4,
1149
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
1150
    
1151
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1152
                 &cbpy_tab[0][1], 2, 1,
1153
                 &cbpy_tab[0][0], 2, 1, 1);
1154
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1155
                 &v2_intra_cbpc[0][1], 2, 1,
1156
                 &v2_intra_cbpc[0][0], 2, 1, 1);
1157
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1158
                 &v2_mb_type[0][1], 2, 1,
1159
                 &v2_mb_type[0][0], 2, 1, 1);
1160
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1161
                 &mvtab[0][1], 2, 1,
1162
                 &mvtab[0][0], 2, 1, 1);
1163

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1405
    return 0;
1406
}
1407

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

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

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

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

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

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

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

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

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

    
1477
    return val;
1478
}
1479

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1962
    return level;
1963
}
1964

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

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

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

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

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

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