← 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): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/msmpeg4.c
3
3
 * Copyright (c) 2001 Fabrice Bellard.
4
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
5
 *
 
6
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
 
7
 *
6
8
 * This file is part of FFmpeg.
7
9
 *
8
10
 * FFmpeg is free software; you can redistribute it and/or
18
20
 * You should have received a copy of the GNU Lesser General Public
19
21
 * License along with FFmpeg; if not, write to the Free Software
20
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 
 *
22
 
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
23
23
 */
24
24
 
25
25
/**
30
30
#include "avcodec.h"
31
31
#include "dsputil.h"
32
32
#include "mpegvideo.h"
 
33
#include "msmpeg4.h"
33
34
 
34
35
/*
35
36
 * You can also call this codec : MPEG4 with a twist !
42
43
 
43
44
#define DC_VLC_BITS 9
44
45
#define CBPY_VLC_BITS 6
45
 
#define INTER_INTRA_VLC_BITS 3
46
46
#define V1_INTRA_CBPC_VLC_BITS 6
47
47
#define V1_INTER_CBPC_VLC_BITS 6
48
48
#define V2_INTRA_CBPC_VLC_BITS 3
50
50
#define MV_VLC_BITS 9
51
51
#define V2_MV_VLC_BITS 9
52
52
#define TEX_VLC_BITS 9
53
 
#define MB_NON_INTRA_VLC_BITS 9
54
 
#define MB_INTRA_VLC_BITS 9
55
53
 
56
54
#define II_BITRATE 128*1024
57
55
#define MBAC_BITRATE 50*1024
61
59
static uint32_t v2_dc_lum_table[512][2];
62
60
static uint32_t v2_dc_chroma_table[512][2];
63
61
 
64
 
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
65
 
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
66
 
                                       int n, int coded, const uint8_t *scantable);
67
62
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
68
 
static int msmpeg4_decode_motion(MpegEncContext * s,
69
 
                                 int *mx_ptr, int *my_ptr);
70
63
static void init_h263_dc_for_msmpeg4(void);
71
64
static inline void msmpeg4_memsetw(short *tab, int val, int n);
72
65
#ifdef CONFIG_ENCODERS
75
68
#endif //CONFIG_ENCODERS
76
69
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
77
70
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
78
 
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
79
71
 
80
72
/* vc1 externs */
81
 
extern uint8_t wmv3_dc_scale_table[32];
 
73
extern const uint8_t wmv3_dc_scale_table[32];
82
74
 
83
75
#ifdef DEBUG
84
76
int intra_count = 0;
87
79
 
88
80
#include "msmpeg4data.h"
89
81
 
90
 
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references
 
82
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if it is not references
91
83
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
92
84
#endif //CONFIG_ENCODERS
93
85
 
 
86
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3];
 
87
 
94
88
static void common_init(MpegEncContext * s)
95
89
{
96
 
    static int inited=0;
 
90
    static int initialized=0;
97
91
 
98
92
    switch(s->msmpeg4_version){
99
93
    case 1:
133
127
    }
134
128
    //Note the default tables are set in common_init in mpegvideo.c
135
129
 
136
 
    if(!inited){
137
 
        inited=1;
 
130
    if(!initialized){
 
131
        initialized=1;
138
132
 
139
133
        init_h263_dc_for_msmpeg4();
140
134
    }
159
153
    }
160
154
}
161
155
 
162
 
static void code012(PutBitContext *pb, int n)
 
156
void ff_msmpeg4_code012(PutBitContext *pb, int n)
163
157
{
164
158
    if (n == 0) {
165
159
        put_bits(pb, 1, 0);
186
180
        init_mv_table(&mv_tables[0]);
187
181
        init_mv_table(&mv_tables[1]);
188
182
        for(i=0;i<NB_RL_TABLES;i++)
189
 
            init_rl(&rl_table[i], 1);
 
183
            init_rl(&rl_table[i], static_rl_table_store[i]);
190
184
 
191
185
        for(i=0; i<NB_RL_TABLES; i++){
192
186
            int level;
244
238
    return size;
245
239
}
246
240
 
247
 
static void find_best_tables(MpegEncContext * s)
 
241
void ff_find_best_tables(MpegEncContext * s)
248
242
{
249
243
    int i;
250
244
    int best       =-1, best_size       =9999999;
269
263
                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
270
264
                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
271
265
 
272
 
                    if(s->pict_type==I_TYPE){
 
266
                    if(s->pict_type==FF_I_TYPE){
273
267
                        size       += intra_luma_count  *rl_length[i  ][level][run][last];
274
268
                        chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
275
269
                    }else{
294
288
//    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
295
289
//           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
296
290
 
297
 
    if(s->pict_type==P_TYPE) chroma_best= best;
 
291
    if(s->pict_type==FF_P_TYPE) chroma_best= best;
298
292
 
299
293
    memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
300
294
 
303
297
 
304
298
    if(s->pict_type != s->last_non_b_pict_type){
305
299
        s->rl_table_index= 2;
306
 
        if(s->pict_type==I_TYPE)
 
300
        if(s->pict_type==FF_I_TYPE)
307
301
            s->rl_chroma_table_index= 1;
308
302
        else
309
303
            s->rl_chroma_table_index= 2;
314
308
/* write MSMPEG4 compatible frame header */
315
309
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
316
310
{
317
 
    find_best_tables(s);
 
311
    ff_find_best_tables(s);
318
312
 
319
313
    align_put_bits(&s->pb);
320
314
    put_bits(&s->pb, 2, s->pict_type - 1);
330
324
    s->use_skip_mb_code = 1; /* only if P frame */
331
325
    s->per_mb_rl_table = 0;
332
326
    if(s->msmpeg4_version==4)
333
 
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
 
327
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE);
334
328
//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
335
329
 
336
 
    if (s->pict_type == I_TYPE) {
 
330
    if (s->pict_type == FF_I_TYPE) {
337
331
        s->slice_height= s->mb_height/1;
338
332
        put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
339
333
 
345
339
 
346
340
        if(s->msmpeg4_version>2){
347
341
            if(!s->per_mb_rl_table){
348
 
                code012(&s->pb, s->rl_chroma_table_index);
349
 
                code012(&s->pb, s->rl_table_index);
 
342
                ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
 
343
                ff_msmpeg4_code012(&s->pb, s->rl_table_index);
350
344
            }
351
345
 
352
346
            put_bits(&s->pb, 1, s->dc_table_index);
359
353
 
360
354
        if(s->msmpeg4_version>2){
361
355
            if(!s->per_mb_rl_table)
362
 
                code012(&s->pb, s->rl_table_index);
 
356
                ff_msmpeg4_code012(&s->pb, s->rl_table_index);
363
357
 
364
358
            put_bits(&s->pb, 1, s->dc_table_index);
365
359
 
391
385
#endif //CONFIG_ENCODERS
392
386
 
393
387
/* predict coded block */
394
 
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
 
388
int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
395
389
{
396
390
    int xy, wrap, pred, a, b, c;
397
391
 
419
413
 
420
414
#ifdef CONFIG_ENCODERS
421
415
 
422
 
static void msmpeg4_encode_motion(MpegEncContext * s,
 
416
void ff_msmpeg4_encode_motion(MpegEncContext * s,
423
417
                                  int mx, int my)
424
418
{
425
419
    int code;
451
445
             mv->table_mv_bits[code],
452
446
             mv->table_mv_code[code]);
453
447
    if (code == mv->n) {
454
 
        /* escape : code litterally */
 
448
        /* escape : code literally */
455
449
        put_bits(&s->pb, 6, mx);
456
450
        put_bits(&s->pb, 6, my);
457
451
    }
458
452
}
459
453
 
460
 
static inline void handle_slices(MpegEncContext *s){
 
454
void ff_msmpeg4_handle_slices(MpegEncContext *s){
461
455
    if (s->mb_x == 0) {
462
456
        if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
463
457
            if(s->msmpeg4_version < 4){
478
472
    int pred_x, pred_y;
479
473
    uint8_t *coded_block;
480
474
 
481
 
    handle_slices(s);
 
475
    ff_msmpeg4_handle_slices(s);
482
476
 
483
477
    if (!s->mb_intra) {
484
478
        /* compute cbp */
524
518
 
525
519
            /* motion vector */
526
520
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
527
 
            msmpeg4_encode_motion(s, motion_x - pred_x,
 
521
            ff_msmpeg4_encode_motion(s, motion_x - pred_x,
528
522
                                  motion_y - pred_y);
529
523
        }
530
524
 
531
525
        s->mv_bits += get_bits_diff(s);
532
526
 
533
527
        for (i = 0; i < 6; i++) {
534
 
            msmpeg4_encode_block(s, block[i], i);
 
528
            ff_msmpeg4_encode_block(s, block[i], i);
535
529
        }
536
530
        s->p_tex_bits += get_bits_diff(s);
537
531
    } else {
544
538
            cbp |= val << (5 - i);
545
539
            if (i < 4) {
546
540
                /* predict value for close blocks only for luma */
547
 
                pred = coded_block_pred(s, i, &coded_block);
 
541
                pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
548
542
                *coded_block = val;
549
543
                val = val ^ pred;
550
544
            }
556
550
#endif
557
551
 
558
552
        if(s->msmpeg4_version<=2){
559
 
            if (s->pict_type == I_TYPE) {
 
553
            if (s->pict_type == FF_I_TYPE) {
560
554
                put_bits(&s->pb,
561
555
                         v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
562
556
            } else {
571
565
                     cbpy_tab[cbp>>2][1],
572
566
                     cbpy_tab[cbp>>2][0]);
573
567
        }else{
574
 
            if (s->pict_type == I_TYPE) {
 
568
            if (s->pict_type == FF_I_TYPE) {
575
569
                put_bits(&s->pb,
576
570
                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
577
571
            } else {
590
584
        s->misc_bits += get_bits_diff(s);
591
585
 
592
586
        for (i = 0; i < 6; i++) {
593
 
            msmpeg4_encode_block(s, block[i], i);
 
587
            ff_msmpeg4_encode_block(s, block[i], i);
594
588
        }
595
589
        s->i_tex_bits += get_bits_diff(s);
596
590
        s->i_count++;
780
774
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
781
775
{
782
776
    int sign, code;
783
 
    int pred;
 
777
    int pred, extquant;
 
778
    int extrabits = 0;
784
779
 
785
780
    if(s->msmpeg4_version==1){
786
781
        int32_t *dc_val;
822
817
        code = level;
823
818
        if (code > DC_MAX)
824
819
            code = DC_MAX;
 
820
        else if( s->msmpeg4_version>=6 ) {
 
821
            if( s->qscale == 1 ) {
 
822
                extquant = (level + 3) & 0x3;
 
823
                code  = ((level+3)>>2);
 
824
            } else if( s->qscale == 2 ) {
 
825
                extquant = (level + 1) & 0x1;
 
826
                code  = ((level+1)>>1);
 
827
            }
 
828
        }
825
829
 
826
830
        if (s->dc_table_index == 0) {
827
831
            if (n < 4) {
837
841
            }
838
842
        }
839
843
 
 
844
        if(s->msmpeg4_version>=6 && s->qscale<=2)
 
845
            extrabits = 3 - s->qscale;
 
846
 
840
847
        if (code == DC_MAX)
841
 
            put_bits(&s->pb, 8, level);
 
848
            put_bits(&s->pb, 8 + extrabits, level);
 
849
        else if(extrabits > 0)//== VC1 && s->qscale<=2
 
850
            put_bits(&s->pb, extrabits, extquant);
842
851
 
843
852
        if (level != 0) {
844
853
            put_bits(&s->pb, 1, sign);
849
858
/* Encoding of a block. Very similar to MPEG4 except for a different
850
859
   escape coding (same as H263) and more vlc tables.
851
860
 */
852
 
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 
861
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
853
862
{
854
863
    int level, run, last, i, j, last_index;
855
864
    int last_non_zero, sign, slevel;
865
874
        } else {
866
875
            rl = &rl_table[3 + s->rl_chroma_table_index];
867
876
        }
868
 
        run_diff = 0;
 
877
        run_diff = s->msmpeg4_version>=4;
869
878
        scantable= s->intra_scantable.permutated;
870
879
    } else {
871
880
        i = 0;
878
887
    }
879
888
 
880
889
    /* recalculate block_last_index for M$ wmv1 */
881
 
    if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
 
890
    if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
882
891
        for(last_index=63; last_index>=0; last_index--){
883
892
            if(block[scantable[last_index]]) break;
884
893
        }
924
933
                    run1 = run - rl->max_run[last][level] - run_diff;
925
934
                    if (run1 < 0)
926
935
                        goto esc3;
 
936
                    code = get_rl_index(rl, last, run1+1, level);
 
937
                    if (s->msmpeg4_version == 4 && code == rl->n)
 
938
                        goto esc3;
927
939
                    code = get_rl_index(rl, last, run1, level);
928
940
                    if (code == rl->n) {
929
941
                    esc3:
934
946
                            if(s->esc3_level_length==0){
935
947
                                s->esc3_level_length=8;
936
948
                                s->esc3_run_length= 6;
 
949
                                //ESCLVLSZ + ESCRUNSZ
937
950
                                if(s->qscale<8)
938
 
                                    put_bits(&s->pb, 6, 3);
 
951
                                    put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
939
952
                                else
940
953
                                    put_bits(&s->pb, 8, 3);
941
954
                            }
969
982
/****************************************/
970
983
/* decoding stuff */
971
984
 
972
 
static VLC mb_non_intra_vlc[4];
973
 
VLC ff_msmp4_mb_i_vlc;
974
 
VLC ff_msmp4_dc_luma_vlc[2];
975
 
VLC ff_msmp4_dc_chroma_vlc[2];
 
985
VLC ff_mb_non_intra_vlc[4];
976
986
static VLC v2_dc_lum_vlc;
977
987
static VLC v2_dc_chroma_vlc;
978
988
static VLC cbpy_vlc;
981
991
static VLC v2_mv_vlc;
982
992
static VLC v1_intra_cbpc_vlc;
983
993
static VLC v1_inter_cbpc_vlc;
984
 
static VLC inter_intra_vlc;
 
994
VLC ff_inter_intra_vlc;
985
995
 
986
 
/* this table is practically identical to the one from h263 except that its inverted */
 
996
/* This table is practically identical to the one from h263
 
997
 * except that it is inverted. */
987
998
static void init_h263_dc_for_msmpeg4(void)
988
999
{
989
1000
        int level, uni_code, uni_len;
1006
1017
            /* luminance h263 */
1007
1018
            uni_code= DCtab_lum[size][0];
1008
1019
            uni_len = DCtab_lum[size][1];
1009
 
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
 
1020
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1010
1021
 
1011
1022
            if (size > 0) {
1012
1023
                uni_code<<=size; uni_code|=l;
1022
1033
            /* chrominance h263 */
1023
1034
            uni_code= DCtab_chrom[size][0];
1024
1035
            uni_len = DCtab_chrom[size][1];
1025
 
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
 
1036
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1026
1037
 
1027
1038
            if (size > 0) {
1028
1039
                uni_code<<=size; uni_code|=l;
1051
1062
        done = 1;
1052
1063
 
1053
1064
        for(i=0;i<NB_RL_TABLES;i++) {
1054
 
            init_rl(&rl_table[i], 1);
 
1065
            init_rl(&rl_table[i], static_rl_table_store[i]);
1055
1066
            init_vlc_rl(&rl_table[i], 1);
1056
1067
        }
1057
1068
        for(i=0;i<2;i++) {
1095
1106
                 &mvtab[0][0], 2, 1, 1);
1096
1107
 
1097
1108
        for(i=0; i<4; i++){
1098
 
            init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
 
1109
            init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1099
1110
                     &wmv2_inter_table[i][0][1], 8, 4,
1100
1111
                     &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1101
1112
        }
1111
1122
                 inter_MCBPC_bits, 1, 1,
1112
1123
                 inter_MCBPC_code, 1, 1, 1);
1113
1124
 
1114
 
        init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
 
1125
        init_vlc(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1115
1126
                 &table_inter_intra[0][1], 2, 1,
1116
1127
                 &table_inter_intra[0][0], 2, 1, 1);
1117
1128
    }
1126
1137
        s->decode_mb= msmpeg4v34_decode_mb;
1127
1138
        break;
1128
1139
    case 5:
1129
 
        s->decode_mb= wmv2_decode_mb;
 
1140
        if (ENABLE_WMV2_DECODER)
 
1141
            s->decode_mb= ff_wmv2_decode_mb;
1130
1142
    case 6:
1131
1143
        //FIXME + TODO VC1 decode mb
1132
1144
        break;
1133
1145
    }
1134
1146
 
1135
 
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
 
1147
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1136
1148
 
1137
1149
    return 0;
1138
1150
}
1164
1176
    }
1165
1177
 
1166
1178
    s->pict_type = get_bits(&s->gb, 2) + 1;
1167
 
    if (s->pict_type != I_TYPE &&
1168
 
        s->pict_type != P_TYPE){
 
1179
    if (s->pict_type != FF_I_TYPE &&
 
1180
        s->pict_type != FF_P_TYPE){
1169
1181
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1170
1182
        return -1;
1171
1183
    }
1172
1184
#if 0
1173
1185
{
1174
1186
    static int had_i=0;
1175
 
    if(s->pict_type == I_TYPE) had_i=1;
 
1187
    if(s->pict_type == FF_I_TYPE) had_i=1;
1176
1188
    if(!had_i) return -1;
1177
1189
}
1178
1190
#endif
1182
1194
        return -1;
1183
1195
    }
1184
1196
 
1185
 
    if (s->pict_type == I_TYPE) {
 
1197
    if (s->pict_type == FF_I_TYPE) {
1186
1198
        code = get_bits(&s->gb, 5);
1187
1199
        if(s->msmpeg4_version==1){
1188
1200
            if(code==0 || code>s->mb_height){
1380
1392
}
1381
1393
#endif
1382
1394
 
1383
 
/* this is identical to h263 except that its range is multiplied by 2 */
 
1395
/* This is identical to h263 except that its range is multiplied by 2. */
1384
1396
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1385
1397
{
1386
1398
    int code, val, sign, shift;
1416
1428
{
1417
1429
    int cbp, code, i;
1418
1430
 
1419
 
    if (s->pict_type == P_TYPE) {
 
1431
    if (s->pict_type == FF_P_TYPE) {
1420
1432
        if (s->use_skip_mb_code) {
1421
1433
            if (get_bits1(&s->gb)) {
1422
1434
                /* skip mb */
1483
1495
        } else{
1484
1496
            s->ac_pred = 0;
1485
1497
            cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1486
 
            if(s->pict_type==P_TYPE) cbp^=0x3C;
 
1498
            if(s->pict_type==FF_P_TYPE) cbp^=0x3C;
1487
1499
        }
1488
1500
    }
1489
1501
 
1490
1502
    s->dsp.clear_blocks(s->block[0]);
1491
1503
    for (i = 0; i < 6; i++) {
1492
 
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 
1504
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1493
1505
        {
1494
1506
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1495
1507
             return -1;
1504
1516
    uint8_t *coded_val;
1505
1517
    uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1506
1518
 
1507
 
    if (s->pict_type == P_TYPE) {
 
1519
    if (s->pict_type == FF_P_TYPE) {
1508
1520
        if (s->use_skip_mb_code) {
1509
1521
            if (get_bits1(&s->gb)) {
1510
1522
                /* skip mb */
1522
1534
            }
1523
1535
        }
1524
1536
 
1525
 
        code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
 
1537
        code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1526
1538
        if (code < 0)
1527
1539
            return -1;
1528
1540
        //s->mb_intra = (code & 0x40) ? 0 : 1;
1539
1551
        for(i=0;i<6;i++) {
1540
1552
            int val = ((code >> (5 - i)) & 1);
1541
1553
            if (i < 4) {
1542
 
                int pred = coded_block_pred(s, i, &coded_val);
 
1554
                int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
1543
1555
                val = val ^ pred;
1544
1556
                *coded_val = val;
1545
1557
            }
1555
1567
            s->rl_chroma_table_index = s->rl_table_index;
1556
1568
        }
1557
1569
        h263_pred_motion(s, 0, 0, &mx, &my);
1558
 
        if (msmpeg4_decode_motion(s, &mx, &my) < 0)
 
1570
        if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
1559
1571
            return -1;
1560
1572
        s->mv_dir = MV_DIR_FORWARD;
1561
1573
        s->mv_type = MV_TYPE_16X16;
1567
1579
        s->ac_pred = get_bits1(&s->gb);
1568
1580
        *mb_type_ptr = MB_TYPE_INTRA;
1569
1581
        if(s->inter_intra_pred){
1570
 
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
 
1582
            s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1571
1583
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1572
1584
        }
1573
1585
        if(s->per_mb_rl_table && cbp){
1578
1590
 
1579
1591
    s->dsp.clear_blocks(s->block[0]);
1580
1592
    for (i = 0; i < 6; i++) {
1581
 
        if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 
1593
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1582
1594
        {
1583
1595
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1584
1596
            return -1;
1588
1600
    return 0;
1589
1601
}
1590
1602
//#define ERROR_DETAILS
1591
 
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
 
1603
int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1592
1604
                              int n, int coded, const uint8_t *scan_table)
1593
1605
{
1594
1606
    int level, i, last, run, run_diff;
1624
1636
        }
1625
1637
        block[0] = level;
1626
1638
 
1627
 
        run_diff = 0;
 
1639
        run_diff = s->msmpeg4_version >= 4;
1628
1640
        i = 0;
1629
1641
        if (!coded) {
1630
1642
            goto not_coded;
1892
1904
    return level;
1893
1905
}
1894
1906
 
1895
 
static int msmpeg4_decode_motion(MpegEncContext * s,
 
1907
int ff_msmpeg4_decode_motion(MpegEncContext * s,
1896
1908
                                 int *mx_ptr, int *my_ptr)
1897
1909
{
1898
1910
    MVTable *mv;
1930
1942
    *my_ptr = my;
1931
1943
    return 0;
1932
1944
}
1933
 
 
1934
 
/* cleanest way to support it
1935
 
 * there is too much shared between versions so that we cant have 1 file per version & 1 common
1936
 
 * as allmost everything would be in the common file
1937
 
 */
1938
 
#include "wmv2.c"