← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/msmpeg4.c

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-02-25 15:47:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080225154712-qvr11ekcea4c9ry8
Tags: 1.1.6-0.1ubuntu1
https://launchpad.net/bugs/120003
* Merge from debian-multimedia (LP: #120003), Ubuntu Changes:
 - For ffmpeg-related build-deps, remove cvs from package names.
 - Standards-Version 3.7.3
 - Maintainer Spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/msmpeg4.c
1
1
/*
2
2
 * MSMPEG4 backend for ffmpeg encoder and decoder
3
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 
 *
5
 
 * This library is free software; you can redistribute it and/or
 
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 
5
 *
 
6
 * This file is part of FFmpeg.
 
7
 *
 
8
 * FFmpeg is free software; you can redistribute it and/or
6
9
 * modify it under the terms of the GNU Lesser General Public
7
10
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
 
11
 * version 2.1 of the License, or (at your option) any later version.
9
12
 *
10
 
 * This library is distributed in the hope that it will be useful,
 
13
 * FFmpeg is distributed in the hope that it will be useful,
11
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
16
 * Lesser General Public License for more details.
14
17
 *
15
18
 * You should have received a copy of the GNU Lesser General Public
16
 
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 * License along with FFmpeg; if not, write to the Free Software
 
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
21
 *
19
22
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
20
23
 */
29
32
#include "mpegvideo.h"
30
33
 
31
34
/*
32
 
 * You can also call this codec : MPEG4 with a twist ! 
 
35
 * You can also call this codec : MPEG4 with a twist !
33
36
 *
34
 
 * TODO: 
 
37
 * TODO:
35
38
 *        - (encoding) select best mv table (two choices)
36
 
 *        - (encoding) select best vlc/dc table 
 
39
 *        - (encoding) select best vlc/dc table
37
40
 */
38
41
//#define DEBUG
39
42
 
62
65
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
63
66
                                       int n, int coded, const uint8_t *scantable);
64
67
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
65
 
static int msmpeg4_decode_motion(MpegEncContext * s, 
 
68
static int msmpeg4_decode_motion(MpegEncContext * s,
66
69
                                 int *mx_ptr, int *my_ptr);
67
 
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
68
70
static void init_h263_dc_for_msmpeg4(void);
69
71
static inline void msmpeg4_memsetw(short *tab, int val, int n);
70
72
#ifdef CONFIG_ENCODERS
 
73
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
71
74
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
72
75
#endif //CONFIG_ENCODERS
73
76
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
74
77
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
75
78
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
76
79
 
 
80
/* vc1 externs */
 
81
extern uint8_t wmv3_dc_scale_table[32];
77
82
 
78
83
#ifdef DEBUG
79
84
int intra_count = 0;
86
91
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
87
92
#endif //CONFIG_ENCODERS
88
93
 
89
 
#ifdef STATS
90
 
 
91
 
const char *st_names[ST_NB] = {
92
 
    "unknown",
93
 
    "dc",
94
 
    "intra_ac",
95
 
    "inter_ac",
96
 
    "intra_mb",
97
 
    "inter_mb",
98
 
    "mv",
99
 
};
100
 
 
101
 
int st_current_index = 0;
102
 
unsigned int st_bit_counts[ST_NB];
103
 
unsigned int st_out_bit_counts[ST_NB];
104
 
 
105
 
#define set_stat(var) st_current_index = var;
106
 
 
107
 
void print_stats(void)
108
 
{
109
 
    unsigned int total;
110
 
    int i;
111
 
 
112
 
    printf("Input:\n");
113
 
    total = 0;
114
 
    for(i=0;i<ST_NB;i++)
115
 
        total += st_bit_counts[i];
116
 
    if (total == 0)
117
 
        total = 1;
118
 
    for(i=0;i<ST_NB;i++) {
119
 
        printf("%-10s : %10.1f %5.1f%%\n", 
120
 
               st_names[i], 
121
 
               (double)st_bit_counts[i] / 8.0, 
122
 
               (double)st_bit_counts[i] * 100.0 / total);
123
 
    }
124
 
    printf("%-10s : %10.1f %5.1f%%\n",
125
 
           "total", 
126
 
           (double)total / 8.0, 
127
 
           100.0);
128
 
 
129
 
    printf("Output:\n");
130
 
    total = 0;
131
 
    for(i=0;i<ST_NB;i++)
132
 
        total += st_out_bit_counts[i];
133
 
    if (total == 0)
134
 
        total = 1;
135
 
    for(i=0;i<ST_NB;i++) {
136
 
        printf("%-10s : %10.1f %5.1f%%\n", 
137
 
               st_names[i], 
138
 
               (double)st_out_bit_counts[i] / 8.0, 
139
 
               (double)st_out_bit_counts[i] * 100.0 / total);
140
 
    }
141
 
    printf("%-10s : %10.1f %5.1f%%\n",
142
 
           "total", 
143
 
           (double)total / 8.0, 
144
 
           100.0);
145
 
}
146
 
 
147
 
#else
148
 
 
149
 
#define set_stat(var)
150
 
 
151
 
#endif
152
 
 
153
94
static void common_init(MpegEncContext * s)
154
95
{
155
96
    static int inited=0;
156
 
    
 
97
 
157
98
    switch(s->msmpeg4_version){
158
99
    case 1:
159
100
    case 2:
174
115
        s->y_dc_scale_table= wmv1_y_dc_scale_table;
175
116
        s->c_dc_scale_table= wmv1_c_dc_scale_table;
176
117
        break;
 
118
#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)
 
119
    case 6:
 
120
        s->y_dc_scale_table= wmv3_dc_scale_table;
 
121
        s->c_dc_scale_table= wmv3_dc_scale_table;
 
122
        break;
 
123
#endif
 
124
 
177
125
    }
178
126
 
179
 
    
 
127
 
180
128
    if(s->msmpeg4_version>=4){
181
129
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , wmv1_scantable[1]);
182
130
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]);
184
132
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , wmv1_scantable[0]);
185
133
    }
186
134
    //Note the default tables are set in common_init in mpegvideo.c
187
 
    
 
135
 
188
136
    if(!inited){
189
137
        inited=1;
190
138
 
203
151
    /* mark all entries as not used */
204
152
    for(i=0;i<4096;i++)
205
153
        tab->table_mv_index[i] = tab->n;
206
 
    
 
154
 
207
155
    for(i=0;i<tab->n;i++) {
208
156
        x = tab->table_mvx[i];
209
157
        y = tab->table_mvy[i];
238
186
        init_mv_table(&mv_tables[0]);
239
187
        init_mv_table(&mv_tables[1]);
240
188
        for(i=0;i<NB_RL_TABLES;i++)
241
 
            init_rl(&rl_table[i]);
 
189
            init_rl(&rl_table[i], 1);
242
190
 
243
191
        for(i=0; i<NB_RL_TABLES; i++){
244
192
            int level;
259
207
    int size=0;
260
208
    int code;
261
209
    int run_diff= intra ? 0 : 1;
262
 
    
 
210
 
263
211
    code = get_rl_index(rl, last, run, level);
264
212
    size+= rl->table_vlc[code][1];
265
213
    if (code == rl->n) {
266
214
        int level1, run1;
267
215
 
268
216
        level1 = level - rl->max_level[last][run];
269
 
        if (level1 < 1) 
 
217
        if (level1 < 1)
270
218
            goto esc2;
271
219
        code = get_rl_index(rl, last, run, level1);
272
220
        if (code == rl->n) {
308
256
        int size=0;
309
257
 
310
258
        if(i>0){// ;)
311
 
            size++; 
 
259
            size++;
312
260
            chroma_size++;
313
261
        }
314
262
        for(level=0; level<=MAX_LEVEL; level++){
320
268
                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
321
269
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
322
270
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
323
 
                    
 
271
 
324
272
                    if(s->pict_type==I_TYPE){
325
273
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
326
274
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
328
276
                        size+=        intra_luma_count  *rl_length[i  ][level][run][last]
329
277
                                     +intra_chroma_count*rl_length[i+3][level][run][last]
330
278
                                     +inter_count       *rl_length[i+3][level][run][last];
331
 
                    }                   
 
279
                    }
332
280
                }
333
281
                if(last_size == size+chroma_size) break;
334
282
            }
343
291
        }
344
292
    }
345
293
 
346
 
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", 
 
294
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
347
295
//           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
348
 
           
 
296
 
349
297
    if(s->pict_type==P_TYPE) chroma_best= best;
350
298
 
351
299
    memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
352
300
 
353
301
    s->rl_table_index       =        best;
354
302
    s->rl_chroma_table_index= chroma_best;
355
 
    
 
303
 
356
304
    if(s->pict_type != s->last_non_b_pict_type){
357
305
        s->rl_table_index= 2;
358
306
        if(s->pict_type==I_TYPE)
388
336
    if (s->pict_type == I_TYPE) {
389
337
        s->slice_height= s->mb_height/1;
390
338
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
391
 
        
 
339
 
392
340
        if(s->msmpeg4_version==4){
393
341
            msmpeg4_encode_ext_header(s);
394
342
            if(s->bit_rate>MBAC_BITRATE)
405
353
        }
406
354
    } else {
407
355
        put_bits(&s->pb, 1, s->use_skip_mb_code);
408
 
        
 
356
 
409
357
        if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
410
358
            put_bits(&s->pb, 1, s->per_mb_rl_table);
411
359
 
424
372
 
425
373
#ifdef DEBUG
426
374
    intra_count = 0;
427
 
    printf("*****frame %d:\n", frame_count++);
 
375
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
428
376
#endif
429
377
}
430
378
 
431
379
void msmpeg4_encode_ext_header(MpegEncContext * s)
432
380
{
433
 
        put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
 
381
        put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
434
382
 
435
383
        put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
436
384
 
448
396
    int xy, wrap, pred, a, b, c;
449
397
 
450
398
    xy = s->block_index[n];
451
 
    wrap = s->block_wrap[0];
 
399
    wrap = s->b8_stride;
452
400
 
453
401
    /* B C
454
 
     * A X 
 
402
     * A X
455
403
     */
456
404
    a = s->coded_block[xy - 1       ];
457
405
    b = s->coded_block[xy - 1 - wrap];
458
406
    c = s->coded_block[xy     - wrap];
459
 
    
 
407
 
460
408
    if (b == c) {
461
409
        pred = a;
462
410
    } else {
463
411
        pred = c;
464
412
    }
465
 
    
 
413
 
466
414
    /* store value */
467
415
    *coded_block_ptr = &s->coded_block[xy];
468
416
 
471
419
 
472
420
#ifdef CONFIG_ENCODERS
473
421
 
474
 
static void msmpeg4_encode_motion(MpegEncContext * s, 
 
422
static void msmpeg4_encode_motion(MpegEncContext * s,
475
423
                                  int mx, int my)
476
424
{
477
425
    int code;
488
436
        my += 64;
489
437
    else if (my >= 64)
490
438
        my -= 64;
491
 
    
 
439
 
492
440
    mx += 32;
493
441
    my += 32;
494
442
#if 0
495
443
    if ((unsigned)mx >= 64 ||
496
 
        (unsigned)my >= 64) 
497
 
        fprintf(stderr, "error mx=%d my=%d\n", mx, my);
 
444
        (unsigned)my >= 64)
 
445
        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
498
446
#endif
499
447
    mv = &mv_tables[s->mv_table_index];
500
448
 
501
449
    code = mv->table_mv_index[(mx << 6) | my];
502
 
    set_stat(ST_MV);
503
 
    put_bits(&s->pb, 
504
 
             mv->table_mv_bits[code], 
 
450
    put_bits(&s->pb,
 
451
             mv->table_mv_bits[code],
505
452
             mv->table_mv_code[code]);
506
453
    if (code == mv->n) {
507
454
        /* escape : code litterally */
518
465
            }
519
466
            s->first_slice_line = 1;
520
467
        } else {
521
 
            s->first_slice_line = 0; 
 
468
            s->first_slice_line = 0;
522
469
        }
523
470
    }
524
471
}
525
472
 
526
 
void msmpeg4_encode_mb(MpegEncContext * s, 
 
473
void msmpeg4_encode_mb(MpegEncContext * s,
527
474
                       DCTELEM block[6][64],
528
475
                       int motion_x, int motion_y)
529
476
{
532
479
    uint8_t *coded_block;
533
480
 
534
481
    handle_slices(s);
535
 
    
 
482
 
536
483
    if (!s->mb_intra) {
537
 
        /* compute cbp */
538
 
        set_stat(ST_INTER_MB);
539
 
        cbp = 0;
540
 
        for (i = 0; i < 6; i++) {
541
 
            if (s->block_last_index[i] >= 0)
542
 
                cbp |= 1 << (5 - i);
543
 
        }
544
 
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
545
 
            /* skip macroblock */
546
 
            put_bits(&s->pb, 1, 1);
 
484
        /* compute cbp */
 
485
        cbp = 0;
 
486
        for (i = 0; i < 6; i++) {
 
487
            if (s->block_last_index[i] >= 0)
 
488
                cbp |= 1 << (5 - i);
 
489
        }
 
490
        if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
 
491
            /* skip macroblock */
 
492
            put_bits(&s->pb, 1, 1);
547
493
            s->last_bits++;
548
 
            s->misc_bits++;
 
494
            s->misc_bits++;
549
495
            s->skip_count++;
550
496
 
551
 
            return;
552
 
        }
 
497
            return;
 
498
        }
553
499
        if (s->use_skip_mb_code)
554
 
            put_bits(&s->pb, 1, 0);     /* mb coded */
555
 
        
 
500
            put_bits(&s->pb, 1, 0);     /* mb coded */
 
501
 
556
502
        if(s->msmpeg4_version<=2){
557
 
            put_bits(&s->pb, 
558
 
                     v2_mb_type[cbp&3][1], 
 
503
            put_bits(&s->pb,
 
504
                     v2_mb_type[cbp&3][1],
559
505
                     v2_mb_type[cbp&3][0]);
560
506
            if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
561
507
            else             coded_cbp= cbp;
562
508
 
563
 
            put_bits(&s->pb, 
564
 
                     cbpy_tab[coded_cbp>>2][1], 
 
509
            put_bits(&s->pb,
 
510
                     cbpy_tab[coded_cbp>>2][1],
565
511
                     cbpy_tab[coded_cbp>>2][0]);
566
512
 
567
513
            s->misc_bits += get_bits_diff(s);
568
514
 
569
 
            h263_pred_motion(s, 0, &pred_x, &pred_y);
 
515
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
570
516
            msmpeg4v2_encode_motion(s, motion_x - pred_x);
571
517
            msmpeg4v2_encode_motion(s, motion_y - pred_y);
572
518
        }else{
573
 
            put_bits(&s->pb, 
574
 
                     table_mb_non_intra[cbp + 64][1], 
 
519
            put_bits(&s->pb,
 
520
                     table_mb_non_intra[cbp + 64][1],
575
521
                     table_mb_non_intra[cbp + 64][0]);
576
522
 
577
523
            s->misc_bits += get_bits_diff(s);
578
524
 
579
525
            /* motion vector */
580
 
            h263_pred_motion(s, 0, &pred_x, &pred_y);
581
 
            msmpeg4_encode_motion(s, motion_x - pred_x, 
 
526
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
527
            msmpeg4_encode_motion(s, motion_x - pred_x,
582
528
                                  motion_y - pred_y);
583
529
        }
584
530
 
589
535
        }
590
536
        s->p_tex_bits += get_bits_diff(s);
591
537
    } else {
592
 
        /* compute cbp */
593
 
        cbp = 0;
 
538
        /* compute cbp */
 
539
        cbp = 0;
594
540
        coded_cbp = 0;
595
 
        for (i = 0; i < 6; i++) {
 
541
        for (i = 0; i < 6; i++) {
596
542
            int val, pred;
597
543
            val = (s->block_last_index[i] >= 1);
598
544
            cbp |= val << (5 - i);
603
549
                val = val ^ pred;
604
550
            }
605
551
            coded_cbp |= val << (5 - i);
606
 
        }
 
552
        }
607
553
#if 0
608
554
        if (coded_cbp)
609
555
            printf("cbp=%x %x\n", cbp, coded_cbp);
611
557
 
612
558
        if(s->msmpeg4_version<=2){
613
559
            if (s->pict_type == I_TYPE) {
614
 
                put_bits(&s->pb, 
 
560
                put_bits(&s->pb,
615
561
                         v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
616
562
            } else {
617
563
                if (s->use_skip_mb_code)
618
 
                    put_bits(&s->pb, 1, 0);     /* mb coded */
619
 
                put_bits(&s->pb, 
620
 
                         v2_mb_type[(cbp&3) + 4][1], 
 
564
                    put_bits(&s->pb, 1, 0);     /* mb coded */
 
565
                put_bits(&s->pb,
 
566
                         v2_mb_type[(cbp&3) + 4][1],
621
567
                         v2_mb_type[(cbp&3) + 4][0]);
622
568
            }
623
 
            put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
624
 
            put_bits(&s->pb, 
625
 
                     cbpy_tab[cbp>>2][1], 
 
569
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
 
570
            put_bits(&s->pb,
 
571
                     cbpy_tab[cbp>>2][1],
626
572
                     cbpy_tab[cbp>>2][0]);
627
573
        }else{
628
574
            if (s->pict_type == I_TYPE) {
629
 
                set_stat(ST_INTRA_MB);
630
 
                put_bits(&s->pb, 
631
 
                         table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
 
575
                put_bits(&s->pb,
 
576
                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
632
577
            } else {
633
578
                if (s->use_skip_mb_code)
634
 
                    put_bits(&s->pb, 1, 0);     /* mb coded */
635
 
                put_bits(&s->pb, 
636
 
                         table_mb_non_intra[cbp][1], 
 
579
                    put_bits(&s->pb, 1, 0);     /* mb coded */
 
580
                put_bits(&s->pb,
 
581
                         table_mb_non_intra[cbp][1],
637
582
                         table_mb_non_intra[cbp][0]);
638
583
            }
639
 
            set_stat(ST_INTRA_MB);
640
 
            put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
 
584
            put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
641
585
            if(s->inter_intra_pred){
642
586
                s->h263_aic_dir=0;
643
587
                put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
655
599
 
656
600
#endif //CONFIG_ENCODERS
657
601
 
658
 
/* old ffmpeg msmpeg4v3 mode */
659
 
static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
660
 
{
661
 
    if (s->qscale < 5){
662
 
        s->y_dc_scale = 8;
663
 
        s->c_dc_scale = 8;
664
 
    }else if (s->qscale < 9){
665
 
        s->y_dc_scale = 2 * s->qscale;
666
 
        s->c_dc_scale = (s->qscale + 13)>>1;
667
 
    }else{
668
 
        s->y_dc_scale = s->qscale + 8;
669
 
        s->c_dc_scale = (s->qscale + 13)>>1;
670
 
    }
671
 
}
672
 
 
673
 
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
 
602
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
674
603
                                    int32_t **dc_val_ptr)
675
604
{
676
605
    int i;
680
609
    } else {
681
610
        i= n-3;
682
611
    }
683
 
    
 
612
 
684
613
    *dc_val_ptr= &s->last_dc[i];
685
 
    return s->last_dc[i]; 
 
614
    return s->last_dc[i];
686
615
}
687
616
 
688
617
static int get_dc(uint8_t *src, int stride, int scale)
699
628
}
700
629
 
701
630
/* dir = 0: left, dir = 1: top prediction */
702
 
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
703
 
                             uint16_t **dc_val_ptr, int *dir_ptr)
 
631
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
 
632
                             int16_t **dc_val_ptr, int *dir_ptr)
704
633
{
705
634
    int a, b, c, wrap, pred, scale;
706
635
    int16_t *dc_val;
707
636
 
708
637
    /* find prediction */
709
638
    if (n < 4) {
710
 
        scale = s->y_dc_scale;
 
639
        scale = s->y_dc_scale;
711
640
    } else {
712
 
        scale = s->c_dc_scale;
 
641
        scale = s->c_dc_scale;
713
642
    }
714
 
    
 
643
 
715
644
    wrap = s->block_wrap[n];
716
645
    dc_val= s->dc_val[0] + s->block_index[n];
717
646
 
718
647
    /* B C
719
 
     * A X 
 
648
     * A X
720
649
     */
721
650
    a = dc_val[ - 1];
722
651
    b = dc_val[ - 1 - wrap];
723
652
    c = dc_val[ - wrap];
724
 
    
 
653
 
725
654
    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
726
655
        b=c=1024;
727
656
    }
730
659
       necessitate to modify mpegvideo.c. The problem comes from the
731
660
       fact they decided to store the quantized DC (which would lead
732
661
       to problems if Q could vary !) */
733
 
#if defined ARCH_X86 && !defined PIC
 
662
#if (defined(ARCH_X86)) && !defined PIC
734
663
    asm volatile(
735
 
        "movl %3, %%eax         \n\t"
736
 
        "shrl $1, %%eax         \n\t"
737
 
        "addl %%eax, %2         \n\t"
738
 
        "addl %%eax, %1         \n\t"
739
 
        "addl %0, %%eax         \n\t"
740
 
        "mull %4                \n\t"
741
 
        "movl %%edx, %0         \n\t"
742
 
        "movl %1, %%eax         \n\t"
743
 
        "mull %4                \n\t"
744
 
        "movl %%edx, %1         \n\t"
745
 
        "movl %2, %%eax         \n\t"
746
 
        "mull %4                \n\t"
747
 
        "movl %%edx, %2         \n\t"
748
 
        : "+b" (a), "+c" (b), "+D" (c)
749
 
        : "g" (scale), "S" (inverse[scale])
750
 
        : "%eax", "%edx"
 
664
        "movl %3, %%eax         \n\t"
 
665
        "shrl $1, %%eax         \n\t"
 
666
        "addl %%eax, %2         \n\t"
 
667
        "addl %%eax, %1         \n\t"
 
668
        "addl %0, %%eax         \n\t"
 
669
        "mull %4                \n\t"
 
670
        "movl %%edx, %0         \n\t"
 
671
        "movl %1, %%eax         \n\t"
 
672
        "mull %4                \n\t"
 
673
        "movl %%edx, %1         \n\t"
 
674
        "movl %2, %%eax         \n\t"
 
675
        "mull %4                \n\t"
 
676
        "movl %%edx, %2         \n\t"
 
677
        : "+b" (a), "+c" (b), "+D" (c)
 
678
        : "g" (scale), "S" (ff_inverse[scale])
 
679
        : "%eax", "%edx"
751
680
    );
752
681
#else
753
682
    /* #elif defined (ARCH_ALPHA) */
755
684
       common case. But they are costly everywhere...
756
685
     */
757
686
    if (scale == 8) {
758
 
        a = (a + (8 >> 1)) / 8;
759
 
        b = (b + (8 >> 1)) / 8;
760
 
        c = (c + (8 >> 1)) / 8;
 
687
        a = (a + (8 >> 1)) / 8;
 
688
        b = (b + (8 >> 1)) / 8;
 
689
        c = (c + (8 >> 1)) / 8;
761
690
    } else {
762
 
        a = FASTDIV((a + (scale >> 1)), scale);
763
 
        b = FASTDIV((b + (scale >> 1)), scale);
764
 
        c = FASTDIV((c + (scale >> 1)), scale);
 
691
        a = FASTDIV((a + (scale >> 1)), scale);
 
692
        b = FASTDIV((b + (scale >> 1)), scale);
 
693
        c = FASTDIV((c + (scale >> 1)), scale);
765
694
    }
766
695
#endif
767
696
    /* XXX: WARNING: they did not choose the same test as MPEG4. This
770
699
        if(s->inter_intra_pred){
771
700
            uint8_t *dest;
772
701
            int wrap;
773
 
            
 
702
 
774
703
            if(n==1){
775
704
                pred=a;
776
705
                *dir_ptr = 0;
797
726
                else           a= get_dc(dest-8, wrap, scale*8);
798
727
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
799
728
                else           c= get_dc(dest-8*wrap, wrap, scale*8);
800
 
                
 
729
 
801
730
                if (s->h263_aic_dir==0) {
802
731
                    pred= a;
803
732
                    *dir_ptr = 0;
856
785
    if(s->msmpeg4_version==1){
857
786
        int32_t *dc_val;
858
787
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
859
 
        
 
788
 
860
789
        /* update predictor */
861
790
        *dc_val= level;
862
791
    }else{
863
 
        uint16_t *dc_val;
 
792
        int16_t *dc_val;
864
793
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
865
794
 
866
795
        /* update predictor */
876
805
 
877
806
    if(s->msmpeg4_version<=2){
878
807
        if (n < 4) {
879
 
            put_bits(&s->pb, 
 
808
            put_bits(&s->pb,
880
809
                     v2_dc_lum_table[level+256][1],
881
810
                     v2_dc_lum_table[level+256][0]);
882
811
        }else{
883
 
            put_bits(&s->pb, 
 
812
            put_bits(&s->pb,
884
813
                     v2_dc_chroma_table[level+256][1],
885
814
                     v2_dc_chroma_table[level+256][0]);
886
815
        }
891
820
            sign = 1;
892
821
        }
893
822
        code = level;
894
 
        if (code > DC_MAX) 
 
823
        if (code > DC_MAX)
895
824
            code = DC_MAX;
896
825
 
897
826
        if (s->dc_table_index == 0) {
898
827
            if (n < 4) {
899
 
                put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
 
828
                put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
900
829
            } else {
901
 
                put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
 
830
                put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
902
831
            }
903
832
        } else {
904
833
            if (n < 4) {
905
 
                put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
 
834
                put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
906
835
            } else {
907
 
                put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
 
836
                put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
908
837
            }
909
838
        }
910
 
            
 
839
 
911
840
        if (code == DC_MAX)
912
841
            put_bits(&s->pb, 8, level);
913
 
            
 
842
 
914
843
        if (level != 0) {
915
844
            put_bits(&s->pb, 1, sign);
916
845
        }
929
858
    const uint8_t *scantable;
930
859
 
931
860
    if (s->mb_intra) {
932
 
        set_stat(ST_DC);
933
861
        msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
934
862
        i = 1;
935
863
        if (n < 4) {
939
867
        }
940
868
        run_diff = 0;
941
869
        scantable= s->intra_scantable.permutated;
942
 
        set_stat(ST_INTRA_AC);
943
870
    } else {
944
871
        i = 0;
945
872
        rl = &rl_table[3 + s->rl_table_index];
948
875
        else
949
876
            run_diff = 1;
950
877
        scantable= s->inter_scantable.permutated;
951
 
        set_stat(ST_INTER_AC);
952
878
    }
953
879
 
954
880
    /* recalculate block_last_index for M$ wmv1 */
962
888
    /* AC coefs */
963
889
    last_non_zero = i - 1;
964
890
    for (; i <= last_index; i++) {
965
 
        j = scantable[i];
966
 
        level = block[j];
967
 
        if (level) {
968
 
            run = i - last_non_zero - 1;
969
 
            last = (i == last_index);
970
 
            sign = 0;
971
 
            slevel = level;
972
 
            if (level < 0) {
973
 
                sign = 1;
974
 
                level = -level;
975
 
            }
 
891
        j = scantable[i];
 
892
        level = block[j];
 
893
        if (level) {
 
894
            run = i - last_non_zero - 1;
 
895
            last = (i == last_index);
 
896
            sign = 0;
 
897
            slevel = level;
 
898
            if (level < 0) {
 
899
                sign = 1;
 
900
                level = -level;
 
901
            }
976
902
 
977
903
            if(level<=MAX_LEVEL && run<=MAX_RUN){
978
904
                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
987
913
                int level1, run1;
988
914
 
989
915
                level1 = level - rl->max_level[last][run];
990
 
                if (level1 < 1) 
 
916
                if (level1 < 1)
991
917
                    goto esc2;
992
918
                code = get_rl_index(rl, last, run, level1);
993
919
                if (code == rl->n) {
1035
961
            } else {
1036
962
                put_bits(&s->pb, 1, sign);
1037
963
            }
1038
 
            last_non_zero = i;
1039
 
        }
 
964
            last_non_zero = i;
 
965
        }
1040
966
    }
1041
967
}
1042
968
 
1044
970
/* decoding stuff */
1045
971
 
1046
972
static VLC mb_non_intra_vlc[4];
1047
 
static VLC mb_intra_vlc;
1048
 
static VLC dc_lum_vlc[2];
1049
 
static VLC dc_chroma_vlc[2];
 
973
VLC ff_msmp4_mb_i_vlc;
 
974
VLC ff_msmp4_dc_luma_vlc[2];
 
975
VLC ff_msmp4_dc_chroma_vlc[2];
1050
976
static VLC v2_dc_lum_vlc;
1051
977
static VLC v2_dc_chroma_vlc;
1052
978
static VLC cbpy_vlc;
1069
995
            v = abs(level);
1070
996
            while (v) {
1071
997
                v >>= 1;
1072
 
                    size++;
 
998
                    size++;
1073
999
            }
1074
1000
 
1075
1001
            if (level < 0)
1097
1023
            uni_code= DCtab_chrom[size][0];
1098
1024
            uni_len = DCtab_chrom[size][1];
1099
1025
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1100
 
            
 
1026
 
1101
1027
            if (size > 0) {
1102
1028
                uni_code<<=size; uni_code|=l;
1103
1029
                uni_len+=size;
1125
1051
        done = 1;
1126
1052
 
1127
1053
        for(i=0;i<NB_RL_TABLES;i++) {
1128
 
            init_rl(&rl_table[i]);
1129
 
            init_vlc_rl(&rl_table[i]);
 
1054
            init_rl(&rl_table[i], 1);
 
1055
            init_vlc_rl(&rl_table[i], 1);
1130
1056
        }
1131
1057
        for(i=0;i<2;i++) {
1132
1058
            mv = &mv_tables[i];
1133
 
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1, 
 
1059
            init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1134
1060
                     mv->table_mv_bits, 1, 1,
1135
 
                     mv->table_mv_code, 2, 2);
 
1061
                     mv->table_mv_code, 2, 2, 1);
1136
1062
        }
1137
1063
 
1138
 
        init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 
1139
 
                 &table0_dc_lum[0][1], 8, 4,
1140
 
                 &table0_dc_lum[0][0], 8, 4);
1141
 
        init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1142
 
                 &table0_dc_chroma[0][1], 8, 4,
1143
 
                 &table0_dc_chroma[0][0], 8, 4);
1144
 
        init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 
1145
 
                 &table1_dc_lum[0][1], 8, 4,
1146
 
                 &table1_dc_lum[0][0], 8, 4);
1147
 
        init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1148
 
                 &table1_dc_chroma[0][1], 8, 4,
1149
 
                 &table1_dc_chroma[0][0], 8, 4);
1150
 
    
1151
 
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 
 
1064
        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
 
1065
                 &ff_table0_dc_lum[0][1], 8, 4,
 
1066
                 &ff_table0_dc_lum[0][0], 8, 4, 1);
 
1067
        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
 
1068
                 &ff_table0_dc_chroma[0][1], 8, 4,
 
1069
                 &ff_table0_dc_chroma[0][0], 8, 4, 1);
 
1070
        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
 
1071
                 &ff_table1_dc_lum[0][1], 8, 4,
 
1072
                 &ff_table1_dc_lum[0][0], 8, 4, 1);
 
1073
        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
 
1074
                 &ff_table1_dc_chroma[0][1], 8, 4,
 
1075
                 &ff_table1_dc_chroma[0][0], 8, 4, 1);
 
1076
 
 
1077
        init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1152
1078
                 &v2_dc_lum_table[0][1], 8, 4,
1153
 
                 &v2_dc_lum_table[0][0], 8, 4);
1154
 
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 
 
1079
                 &v2_dc_lum_table[0][0], 8, 4, 1);
 
1080
        init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1155
1081
                 &v2_dc_chroma_table[0][1], 8, 4,
1156
 
                 &v2_dc_chroma_table[0][0], 8, 4);
1157
 
    
 
1082
                 &v2_dc_chroma_table[0][0], 8, 4, 1);
 
1083
 
1158
1084
        init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1159
1085
                 &cbpy_tab[0][1], 2, 1,
1160
 
                 &cbpy_tab[0][0], 2, 1);
 
1086
                 &cbpy_tab[0][0], 2, 1, 1);
1161
1087
        init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1162
1088
                 &v2_intra_cbpc[0][1], 2, 1,
1163
 
                 &v2_intra_cbpc[0][0], 2, 1);
 
1089
                 &v2_intra_cbpc[0][0], 2, 1, 1);
1164
1090
        init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1165
1091
                 &v2_mb_type[0][1], 2, 1,
1166
 
                 &v2_mb_type[0][0], 2, 1);
 
1092
                 &v2_mb_type[0][0], 2, 1, 1);
1167
1093
        init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1168
1094
                 &mvtab[0][1], 2, 1,
1169
 
                 &mvtab[0][0], 2, 1);
 
1095
                 &mvtab[0][0], 2, 1, 1);
1170
1096
 
1171
1097
        for(i=0; i<4; i++){
1172
 
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, 
 
1098
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1173
1099
                     &wmv2_inter_table[i][0][1], 8, 4,
1174
 
                     &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
 
1100
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1175
1101
        }
1176
 
        
1177
 
        init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64, 
1178
 
                 &table_mb_intra[0][1], 4, 2,
1179
 
                 &table_mb_intra[0][0], 4, 2);
1180
 
        
1181
 
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, 
 
1102
 
 
1103
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
 
1104
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
 
1105
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
 
1106
 
 
1107
        init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1182
1108
                 intra_MCBPC_bits, 1, 1,
1183
 
                 intra_MCBPC_code, 1, 1);
1184
 
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25, 
 
1109
                 intra_MCBPC_code, 1, 1, 1);
 
1110
        init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1185
1111
                 inter_MCBPC_bits, 1, 1,
1186
 
                 inter_MCBPC_code, 1, 1);
1187
 
        
1188
 
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 
 
1112
                 inter_MCBPC_code, 1, 1, 1);
 
1113
 
 
1114
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1189
1115
                 &table_inter_intra[0][1], 2, 1,
1190
 
                 &table_inter_intra[0][0], 2, 1);
 
1116
                 &table_inter_intra[0][0], 2, 1, 1);
1191
1117
    }
1192
 
    
 
1118
 
1193
1119
    switch(s->msmpeg4_version){
1194
1120
    case 1:
1195
1121
    case 2:
1201
1127
        break;
1202
1128
    case 5:
1203
1129
        s->decode_mb= wmv2_decode_mb;
 
1130
    case 6:
 
1131
        //FIXME + TODO VC1 decode mb
1204
1132
        break;
1205
1133
    }
1206
 
    
 
1134
 
1207
1135
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1208
 
    
 
1136
 
1209
1137
    return 0;
1210
1138
}
1211
1139
 
1212
 
static int decode012(GetBitContext *gb)
1213
 
{
1214
 
    int n;
1215
 
    n = get_bits1(gb);
1216
 
    if (n == 0)
1217
 
        return 0;
1218
 
    else
1219
 
        return get_bits1(gb) + 1;
1220
 
}
1221
 
 
1222
1140
int msmpeg4_decode_picture_header(MpegEncContext * s)
1223
1141
{
1224
1142
    int code;
1227
1145
{
1228
1146
int i;
1229
1147
for(i=0; i<s->gb.size_in_bits; i++)
1230
 
    printf("%d", get_bits1(&s->gb));
 
1148
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1231
1149
//    get_bits1(&s->gb);
1232
 
printf("END\n");
 
1150
av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1233
1151
return -1;
1234
1152
}
1235
1153
#endif
1238
1156
        int start_code, num;
1239
1157
        start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1240
1158
        if(start_code!=0x00000100){
1241
 
            fprintf(stderr, "invalid startcode\n");
 
1159
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1242
1160
            return -1;
1243
1161
        }
1244
1162
 
1248
1166
    s->pict_type = get_bits(&s->gb, 2) + 1;
1249
1167
    if (s->pict_type != I_TYPE &&
1250
1168
        s->pict_type != P_TYPE){
1251
 
        fprintf(stderr, "invalid picture type\n");
 
1169
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1252
1170
        return -1;
1253
1171
    }
1254
1172
#if 0
1258
1176
    if(!had_i) return -1;
1259
1177
}
1260
1178
#endif
1261
 
    s->qscale = get_bits(&s->gb, 5);
 
1179
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1262
1180
    if(s->qscale==0){
1263
 
        fprintf(stderr, "invalid qscale\n");
 
1181
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1264
1182
        return -1;
1265
1183
    }
1266
1184
 
1267
1185
    if (s->pict_type == I_TYPE) {
1268
 
        code = get_bits(&s->gb, 5); 
 
1186
        code = get_bits(&s->gb, 5);
1269
1187
        if(s->msmpeg4_version==1){
1270
1188
            if(code==0 || code>s->mb_height){
1271
 
                fprintf(stderr, "invalid slice height %d\n", code);
 
1189
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1272
1190
                return -1;
1273
1191
            }
1274
1192
 
1276
1194
        }else{
1277
1195
            /* 0x17: one slice, 0x18: two slices, ... */
1278
1196
            if (code < 0x17){
1279
 
                fprintf(stderr, "error, slice code was %X\n", code);
 
1197
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1280
1198
                return -1;
1281
1199
            }
1282
1200
 
1302
1220
 
1303
1221
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1304
1222
            else                           s->per_mb_rl_table= 0;
1305
 
            
 
1223
 
1306
1224
            if(!s->per_mb_rl_table){
1307
1225
                s->rl_chroma_table_index = decode012(&s->gb);
1308
1226
                s->rl_table_index = decode012(&s->gb);
1314
1232
        }
1315
1233
        s->no_rounding = 1;
1316
1234
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1317
 
            printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n", 
1318
 
                s->qscale,
1319
 
                s->rl_chroma_table_index,
1320
 
                s->rl_table_index, 
1321
 
                s->dc_table_index,
 
1235
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
 
1236
                s->qscale,
 
1237
                s->rl_chroma_table_index,
 
1238
                s->rl_table_index,
 
1239
                s->dc_table_index,
1322
1240
                s->per_mb_rl_table,
1323
1241
                s->slice_height);
1324
1242
    } else {
1360
1278
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1361
1279
            break;
1362
1280
        }
1363
 
        
 
1281
 
1364
1282
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1365
 
            printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n", 
1366
 
                s->use_skip_mb_code, 
1367
 
                s->rl_table_index, 
1368
 
                s->rl_chroma_table_index, 
1369
 
                s->dc_table_index,
1370
 
                s->mv_table_index,
 
1283
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
 
1284
                s->use_skip_mb_code,
 
1285
                s->rl_table_index,
 
1286
                s->rl_chroma_table_index,
 
1287
                s->dc_table_index,
 
1288
                s->mv_table_index,
1371
1289
                s->per_mb_rl_table,
1372
1290
                s->qscale);
1373
1291
 
1374
 
        if(s->flipflop_rounding){
1375
 
            s->no_rounding ^= 1;
1376
 
        }else{
1377
 
            s->no_rounding = 0;
1378
 
        }
 
1292
        if(s->flipflop_rounding){
 
1293
            s->no_rounding ^= 1;
 
1294
        }else{
 
1295
            s->no_rounding = 0;
 
1296
        }
1379
1297
    }
1380
1298
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1381
1299
 
1383
1301
    s->esc3_run_length= 0;
1384
1302
 
1385
1303
#ifdef DEBUG
1386
 
    printf("*****frame %d:\n", frame_count++);
 
1304
    av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1387
1305
#endif
1388
1306
    return 0;
1389
1307
}
1410
1328
    {
1411
1329
        s->flipflop_rounding= 0;
1412
1330
        if(s->msmpeg4_version != 2)
1413
 
            printf("ext header missing, %d left\n", left);
 
1331
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1414
1332
    }
1415
1333
    else
1416
1334
    {
1417
 
        fprintf(stderr, "I frame too long, ignoring ext header\n");
 
1335
        av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1418
1336
    }
1419
1337
 
1420
1338
    return 0;
1427
1345
        tab[i] = val;
1428
1346
}
1429
1347
 
 
1348
#ifdef CONFIG_ENCODERS
1430
1349
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1431
1350
{
1432
1351
    int range, bit_size, sign, code, bits;
1453
1372
        code = (val >> bit_size) + 1;
1454
1373
        bits = val & (range - 1);
1455
1374
 
1456
 
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
 
1375
        put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1457
1376
        if (bit_size > 0) {
1458
1377
            put_bits(&s->pb, bit_size, bits);
1459
1378
        }
1460
1379
    }
1461
1380
}
 
1381
#endif
1462
1382
 
1463
1383
/* this is identical to h263 except that its range is multiplied by 2 */
1464
1384
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1495
1415
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1496
1416
{
1497
1417
    int cbp, code, i;
1498
 
    
 
1418
 
1499
1419
    if (s->pict_type == P_TYPE) {
1500
1420
        if (s->use_skip_mb_code) {
1501
1421
            if (get_bits1(&s->gb)) {
1507
1427
                s->mv_type = MV_TYPE_16X16;
1508
1428
                s->mv[0][0][0] = 0;
1509
1429
                s->mv[0][0][1] = 0;
1510
 
                s->mb_skiped = 1;
 
1430
                s->mb_skipped = 1;
1511
1431
                return 0;
1512
1432
            }
1513
1433
        }
1517
1437
        else
1518
1438
            code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1519
1439
        if(code<0 || code>7){
1520
 
            fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
 
1440
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1521
1441
            return -1;
1522
1442
        }
1523
1443
 
1524
1444
        s->mb_intra = code >>2;
1525
 
    
 
1445
 
1526
1446
        cbp = code & 0x3;
1527
1447
    } else {
1528
1448
        s->mb_intra = 1;
1531
1451
        else
1532
1452
            cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1533
1453
        if(cbp<0 || cbp>3){
1534
 
            fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 
1454
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1535
1455
            return -1;
1536
1456
        }
1537
1457
    }
1538
1458
 
1539
1459
    if (!s->mb_intra) {
1540
1460
        int mx, my, cbpy;
1541
 
        
 
1461
 
1542
1462
        cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1543
1463
        if(cbpy<0){
1544
 
            fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 
1464
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1545
1465
            return -1;
1546
1466
        }
1547
1467
 
1548
1468
        cbp|= cbpy<<2;
1549
1469
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1550
 
        
1551
 
        h263_pred_motion(s, 0, &mx, &my);
 
1470
 
 
1471
        h263_pred_motion(s, 0, 0, &mx, &my);
1552
1472
        mx= msmpeg4v2_decode_motion(s, mx, 1);
1553
1473
        my= msmpeg4v2_decode_motion(s, my, 1);
1554
 
        
 
1474
 
1555
1475
        s->mv_dir = MV_DIR_FORWARD;
1556
1476
        s->mv_type = MV_TYPE_16X16;
1557
1477
        s->mv[0][0][0] = mx;
1567
1487
        }
1568
1488
    }
1569
1489
 
 
1490
    s->dsp.clear_blocks(s->block[0]);
1570
1491
    for (i = 0; i < 6; i++) {
1571
1492
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1572
 
        {
1573
 
             fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 
1493
        {
 
1494
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1574
1495
             return -1;
1575
 
        }
 
1496
        }
1576
1497
    }
1577
1498
    return 0;
1578
1499
}
1584
1505
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1585
1506
 
1586
1507
    if (s->pict_type == P_TYPE) {
1587
 
        set_stat(ST_INTER_MB);
1588
1508
        if (s->use_skip_mb_code) {
1589
1509
            if (get_bits1(&s->gb)) {
1590
1510
                /* skip mb */
1595
1515
                s->mv_type = MV_TYPE_16X16;
1596
1516
                s->mv[0][0][0] = 0;
1597
1517
                s->mv[0][0][1] = 0;
1598
 
                s->mb_skiped = 1;
 
1518
                s->mb_skipped = 1;
1599
1519
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1600
1520
 
1601
1521
                return 0;
1602
1522
            }
1603
1523
        }
1604
 
        
 
1524
 
1605
1525
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1606
1526
        if (code < 0)
1607
1527
            return -1;
1608
 
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1609
 
        s->mb_intra = (~code & 0x40) >> 6;
1610
 
            
 
1528
        //s->mb_intra = (code & 0x40) ? 0 : 1;
 
1529
        s->mb_intra = (~code & 0x40) >> 6;
 
1530
 
1611
1531
        cbp = code & 0x3f;
1612
1532
    } else {
1613
 
        set_stat(ST_INTRA_MB);
1614
1533
        s->mb_intra = 1;
1615
 
        code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
 
1534
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1616
1535
        if (code < 0)
1617
1536
            return -1;
1618
1537
        /* predict coded block pattern */
1635
1554
            s->rl_table_index = decode012(&s->gb);
1636
1555
            s->rl_chroma_table_index = s->rl_table_index;
1637
1556
        }
1638
 
        set_stat(ST_MV);
1639
 
        h263_pred_motion(s, 0, &mx, &my);
 
1557
        h263_pred_motion(s, 0, 0, &mx, &my);
1640
1558
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1641
1559
            return -1;
1642
1560
        s->mv_dir = MV_DIR_FORWARD;
1646
1564
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1647
1565
    } else {
1648
1566
//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));
1649
 
        set_stat(ST_INTRA_MB);
1650
1567
        s->ac_pred = get_bits1(&s->gb);
1651
1568
        *mb_type_ptr = MB_TYPE_INTRA;
1652
1569
        if(s->inter_intra_pred){
1659
1576
        }
1660
1577
    }
1661
1578
 
 
1579
    s->dsp.clear_blocks(s->block[0]);
1662
1580
    for (i = 0; i < 6; i++) {
1663
1581
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1664
 
        {
1665
 
            fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1666
 
            return -1;
1667
 
        }
 
1582
        {
 
1583
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 
1584
            return -1;
 
1585
        }
1668
1586
    }
1669
 
    
 
1587
 
1670
1588
    return 0;
1671
1589
}
1672
1590
//#define ERROR_DETAILS
1683
1601
        qmul=1;
1684
1602
        qadd=0;
1685
1603
 
1686
 
        /* DC coef */
1687
 
        set_stat(ST_DC);
 
1604
        /* DC coef */
1688
1605
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1689
 
        
 
1606
 
1690
1607
        if (level < 0){
1691
 
            fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
 
1608
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1692
1609
            if(s->inter_intra_pred) level=0;
1693
1610
            else                    return -1;
1694
1611
        }
1695
1612
        if (n < 4) {
1696
1613
            rl = &rl_table[s->rl_table_index];
1697
1614
            if(level > 256*s->y_dc_scale){
1698
 
                fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
 
1615
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1699
1616
                if(!s->inter_intra_pred) return -1;
1700
1617
            }
1701
1618
        } else {
1702
1619
            rl = &rl_table[3 + s->rl_chroma_table_index];
1703
1620
            if(level > 256*s->c_dc_scale){
1704
 
                fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
 
1621
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1705
1622
                if(!s->inter_intra_pred) return -1;
1706
1623
            }
1707
1624
        }
1713
1630
            goto not_coded;
1714
1631
        }
1715
1632
        if (s->ac_pred) {
1716
 
            if (dc_pred_dir == 0) 
 
1633
            if (dc_pred_dir == 0)
1717
1634
                scan_table = s->intra_v_scantable.permutated; /* left */
1718
1635
            else
1719
1636
                scan_table = s->intra_h_scantable.permutated; /* top */
1720
1637
        } else {
1721
1638
            scan_table = s->intra_scantable.permutated;
1722
1639
        }
1723
 
        set_stat(ST_INTRA_AC);
1724
1640
        rl_vlc= rl->rl_vlc[0];
1725
1641
    } else {
1726
1642
        qmul = s->qscale << 1;
1739
1655
        }
1740
1656
        if(!scan_table)
1741
1657
            scan_table = s->inter_scantable.permutated;
1742
 
        set_stat(ST_INTER_AC);
1743
1658
        rl_vlc= rl->rl_vlc[s->qscale];
1744
1659
    }
1745
1660
  {
1746
1661
    OPEN_READER(re, &s->gb);
1747
1662
    for(;;) {
1748
1663
        UPDATE_CACHE(re, &s->gb);
1749
 
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
 
1664
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1750
1665
        if (level==0) {
1751
1666
            int cache;
1752
1667
            cache= GET_CACHE(re, &s->gb);
1761
1676
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1762
1677
                        level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1763
1678
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
1764
 
                    }else{                        
 
1679
                    }else{
1765
1680
                        int sign;
1766
1681
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1767
1682
                        if(!s->esc3_level_length){
1770
1685
                            if(s->qscale<8){
1771
1686
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1772
1687
                                if(ll==0){
1773
 
                                    if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
 
1688
                                    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");
1774
1689
                                    SKIP_BITS(re, &s->gb, 1);
1775
1690
                                    ll=8;
1776
1691
                                }
1788
1703
//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1789
1704
                            UPDATE_CACHE(re, &s->gb);
1790
1705
                        }
1791
 
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length); 
 
1706
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1792
1707
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
1793
 
                        
1794
 
                        sign=  SHOW_UBITS(re, &s->gb, 1); 
 
1708
 
 
1709
                        sign=  SHOW_UBITS(re, &s->gb, 1);
1795
1710
                        SKIP_BITS(re, &s->gb, 1);
1796
 
                        
1797
 
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); 
 
1711
 
 
1712
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1798
1713
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
1799
1714
                        if(sign) level= -level;
1800
1715
                    }
1801
1716
//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1802
1717
#if 0 // waste of time / this will detect very few errors
1803
1718
                    {
1804
 
                        const int abs_level= ABS(level);
 
1719
                        const int abs_level= FFABS(level);
1805
1720
                        const int run1= run - rl->max_run[last][abs_level] - run_diff;
1806
1721
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1807
1722
                            if(abs_level <= rl->max_level[last][run]){
1808
 
                                fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
 
1723
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1809
1724
                                return DECODING_AC_LOST;
1810
1725
                            }
1811
1726
                            if(abs_level <= rl->max_level[last][run]*2){
1812
 
                                fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
 
1727
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1813
1728
                                return DECODING_AC_LOST;
1814
1729
                            }
1815
1730
                            if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1816
 
                                fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
 
1731
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1817
1732
                                return DECODING_AC_LOST;
1818
1733
                            }
1819
1734
                        }
1820
1735
                    }
1821
1736
#endif
1822
 
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1823
 
                    if (level>0) level= level * qmul + qadd;
 
1737
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
 
1738
                    if (level>0) level= level * qmul + qadd;
1824
1739
                    else         level= level * qmul - qadd;
1825
1740
#if 0 // waste of time too :(
1826
1741
                    if(level>2048 || level<-2048){
1827
 
                        fprintf(stderr, "|level| overflow in 3. esc\n");
 
1742
                        av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1828
1743
                        return DECODING_AC_LOST;
1829
1744
                    }
1830
1745
#endif
1832
1747
                    if(last) i+=192;
1833
1748
#ifdef ERROR_DETAILS
1834
1749
                if(run==66)
1835
 
                    fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
 
1750
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1836
1751
                else if((i>62 && i<192) || i>192+63)
1837
 
                    fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
 
1752
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1838
1753
#endif
1839
1754
                } else {
1840
1755
                    /* second escape */
1844
1759
#else
1845
1760
                    SKIP_BITS(re, &s->gb, 2);
1846
1761
#endif
1847
 
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
 
1762
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1848
1763
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1849
1764
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1850
1765
                    LAST_SKIP_BITS(re, &s->gb, 1);
1851
1766
#ifdef ERROR_DETAILS
1852
1767
                if(run==66)
1853
 
                    fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
 
1768
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1854
1769
                else if((i>62 && i<192) || i>192+63)
1855
 
                    fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
 
1770
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1856
1771
#endif
1857
1772
                }
1858
1773
            } else {
1863
1778
#else
1864
1779
                SKIP_BITS(re, &s->gb, 1);
1865
1780
#endif
1866
 
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
 
1781
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1867
1782
                i+= run;
1868
1783
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1869
1784
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1870
1785
                LAST_SKIP_BITS(re, &s->gb, 1);
1871
1786
#ifdef ERROR_DETAILS
1872
1787
                if(run==66)
1873
 
                    fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
 
1788
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1874
1789
                else if((i>62 && i<192) || i>192+63)
1875
 
                    fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
 
1790
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1876
1791
#endif
1877
1792
            }
1878
1793
        } else {
1881
1796
            LAST_SKIP_BITS(re, &s->gb, 1);
1882
1797
#ifdef ERROR_DETAILS
1883
1798
                if(run==66)
1884
 
                    fprintf(stderr, "illegal vlc code level=%d\n", level);
 
1799
                    av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1885
1800
                else if((i>62 && i<192) || i>192+63)
1886
 
                    fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
 
1801
                    av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1887
1802
#endif
1888
1803
        }
1889
1804
        if (i > 62){
1891
1806
            if(i&(~63)){
1892
1807
                const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1893
1808
                if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1894
 
                    fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
 
1809
                    av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1895
1810
                    break;
1896
1811
                }else{
1897
 
                    fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
 
1812
                    av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1898
1813
                    return -1;
1899
1814
                }
1900
1815
            }
1916
1831
    }
1917
1832
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1918
1833
    s->block_last_index[n] = i;
1919
 
    
 
1834
 
1920
1835
    return 0;
1921
1836
}
1922
1837
 
1930
1845
        } else {
1931
1846
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1932
1847
        }
1933
 
        if (level < 0) 
 
1848
        if (level < 0)
1934
1849
            return -1;
1935
1850
        level-=256;
1936
1851
    }else{  //FIXME optimize use unified tables & index
1937
1852
        if (n < 4) {
1938
 
            level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 
1853
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1939
1854
        } else {
1940
 
            level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 
1855
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1941
1856
        }
1942
1857
        if (level < 0){
1943
 
            fprintf(stderr, "illegal dc vlc\n");
 
1858
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1944
1859
            return -1;
1945
1860
        }
1946
1861
 
1958
1873
        int32_t *dc_val;
1959
1874
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1960
1875
        level += pred;
1961
 
        
 
1876
 
1962
1877
        /* update predictor */
1963
1878
        *dc_val= level;
1964
1879
    }else{
1965
 
        uint16_t *dc_val;
 
1880
        int16_t *dc_val;
1966
1881
        pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1967
1882
        level += pred;
1968
1883
 
1977
1892
    return level;
1978
1893
}
1979
1894
 
1980
 
static int msmpeg4_decode_motion(MpegEncContext * s, 
 
1895
static int msmpeg4_decode_motion(MpegEncContext * s,
1981
1896
                                 int *mx_ptr, int *my_ptr)
1982
1897
{
1983
1898
    MVTable *mv;
1987
1902
 
1988
1903
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1989
1904
    if (code < 0){
1990
 
        fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
 
1905
        av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1991
1906
        return -1;
1992
1907
    }
1993
1908
    if (code == mv->n) {
2018
1933
 
2019
1934
/* cleanest way to support it
2020
1935
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
2021
 
 * as allmost everything would be in the common file 
 
1936
 * as allmost everything would be in the common file
2022
1937
 */
2023
1938
#include "wmv2.c"