GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/msmpeg4dec.c Lines: 408 468 87.2 %
Date: 2021-04-20 15:25:36 Branches: 220 285 77.2 %

Line Branch Exec Source
1
/*
2
 * MSMPEG4 backend for encoder and decoder
3
 * Copyright (c) 2001 Fabrice Bellard
4
 * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24
25
#include "avcodec.h"
26
#include "internal.h"
27
#include "mpegutils.h"
28
#include "mpegvideo.h"
29
#include "msmpeg4.h"
30
#include "libavutil/imgutils.h"
31
#include "h263.h"
32
#include "mpeg4video.h"
33
#include "msmpeg4data.h"
34
#include "vc1data.h"
35
#include "wmv2.h"
36
37
#define DC_VLC_BITS 9
38
#define V2_INTRA_CBPC_VLC_BITS 3
39
#define V2_MB_TYPE_VLC_BITS 7
40
#define MV_VLC_BITS 9
41
#define TEX_VLC_BITS 9
42
43
#define DEFAULT_INTER_INDEX 3
44
45
5490
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
46
                                    int32_t **dc_val_ptr)
47
{
48
    int i;
49
50
5490
    if (n < 4) {
51
3660
        i= 0;
52
    } else {
53
1830
        i= n-3;
54
    }
55
56
5490
    *dc_val_ptr= &s->last_dc[i];
57
5490
    return s->last_dc[i];
58
}
59
60
/****************************************/
61
/* decoding stuff */
62
63
VLC ff_mb_non_intra_vlc[4];
64
static VLC v2_dc_lum_vlc;
65
static VLC v2_dc_chroma_vlc;
66
static VLC v2_intra_cbpc_vlc;
67
static VLC v2_mb_type_vlc;
68
VLC ff_inter_intra_vlc;
69
70
/* This is identical to H.263 except that its range is multiplied by 2. */
71
132268
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
72
{
73
    int code, val, sign, shift;
74
75
132268
    code = get_vlc2(&s->gb, ff_h263_mv_vlc.table, H263_MV_VLC_BITS, 2);
76
    ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
77
132268
    if (code < 0)
78
        return 0xffff;
79
80
132268
    if (code == 0)
81
68571
        return pred;
82
63697
    sign = get_bits1(&s->gb);
83
63697
    shift = f_code - 1;
84
63697
    val = code;
85
63697
    if (shift) {
86
        val = (val - 1) << shift;
87
        val |= get_bits(&s->gb, shift);
88
        val++;
89
    }
90
63697
    if (sign)
91
26289
        val = -val;
92
93
63697
    val += pred;
94
63697
    if (val <= -64)
95
138
        val += 64;
96
63559
    else if (val >= 64)
97
13
        val -= 64;
98
99
63697
    return val;
100
}
101
102
76350
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
103
{
104
    int cbp, code, i;
105
76350
    uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
106
107
76350
    if (s->pict_type == AV_PICTURE_TYPE_P) {
108
70035
        if (s->use_skip_mb_code) {
109
70035
            if (get_bits1(&s->gb)) {
110
                /* skip mb */
111
1159
                s->mb_intra = 0;
112
8113
                for(i=0;i<6;i++)
113
6954
                    s->block_last_index[i] = -1;
114
1159
                s->mv_dir = MV_DIR_FORWARD;
115
1159
                s->mv_type = MV_TYPE_16X16;
116
1159
                s->mv[0][0][0] = 0;
117
1159
                s->mv[0][0][1] = 0;
118
1159
                s->mb_skipped = 1;
119
1159
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
120
1159
                return 0;
121
            }
122
        }
123
124
68876
        if(s->msmpeg4_version==2)
125
53160
            code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
126
        else
127
15716
            code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
128

68876
        if(code<0 || code>7){
129
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
130
            return -1;
131
        }
132
133
68876
        s->mb_intra = code >>2;
134
135
68876
        cbp = code & 0x3;
136
    } else {
137
6315
        s->mb_intra = 1;
138
6315
        if(s->msmpeg4_version==2)
139
5985
            cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
140
        else
141
330
            cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
142

6315
        if(cbp<0 || cbp>3){
143
            av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
144
            return -1;
145
        }
146
    }
147
148
75191
    if (!s->mb_intra) {
149
        int mx, my, cbpy;
150
151
66134
        cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
152
66134
        if(cbpy<0){
153
            av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
154
            return -1;
155
        }
156
157
66134
        cbp|= cbpy<<2;
158

66134
        if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
159
160
66134
        ff_h263_pred_motion(s, 0, 0, &mx, &my);
161
66134
        mx= msmpeg4v2_decode_motion(s, mx, 1);
162
66134
        my= msmpeg4v2_decode_motion(s, my, 1);
163
164
66134
        s->mv_dir = MV_DIR_FORWARD;
165
66134
        s->mv_type = MV_TYPE_16X16;
166
66134
        s->mv[0][0][0] = mx;
167
66134
        s->mv[0][0][1] = my;
168
66134
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
169
    } else {
170
        int v;
171
9057
        if(s->msmpeg4_version==2){
172
8142
            s->ac_pred = get_bits1(&s->gb);
173
8142
            v = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
174
8142
            if (v < 0) {
175
                av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
176
                return -1;
177
            }
178
8142
            cbp|= v<<2;
179
        } else{
180
915
            s->ac_pred = 0;
181
915
            v = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
182
915
            if (v < 0) {
183
                av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
184
                return -1;
185
            }
186
915
            cbp|= v<<2;
187
915
            if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
188
        }
189
9057
        *mb_type_ptr = MB_TYPE_INTRA;
190
    }
191
192
75191
    s->bdsp.clear_blocks(s->block[0]);
193
526337
    for (i = 0; i < 6; i++) {
194
451146
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
195
        {
196
             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
197
             return -1;
198
        }
199
    }
200
75191
    return 0;
201
}
202
203
129600
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
204
{
205
    int cbp, code, i;
206
    uint8_t *coded_val;
207
129600
    uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
208
209
129600
    if (get_bits_left(&s->gb) <= 0)
210
        return AVERROR_INVALIDDATA;
211
212
129600
    if (s->pict_type == AV_PICTURE_TYPE_P) {
213
116442
        if (s->use_skip_mb_code) {
214
116442
            if (get_bits1(&s->gb)) {
215
                /* skip mb */
216
1554
                s->mb_intra = 0;
217
10878
                for(i=0;i<6;i++)
218
9324
                    s->block_last_index[i] = -1;
219
1554
                s->mv_dir = MV_DIR_FORWARD;
220
1554
                s->mv_type = MV_TYPE_16X16;
221
1554
                s->mv[0][0][0] = 0;
222
1554
                s->mv[0][0][1] = 0;
223
1554
                s->mb_skipped = 1;
224
1554
                *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
225
226
1554
                return 0;
227
            }
228
        }
229
230
114888
        code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
231
        //s->mb_intra = (code & 0x40) ? 0 : 1;
232
114888
        s->mb_intra = (~code & 0x40) >> 6;
233
234
114888
        cbp = code & 0x3f;
235
    } else {
236
13158
        s->mb_intra = 1;
237
13158
        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
238
        /* predict coded block pattern */
239
13158
        cbp = 0;
240
92106
        for(i=0;i<6;i++) {
241
78948
            int val = ((code >> (5 - i)) & 1);
242
78948
            if (i < 4) {
243
52632
                int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
244
52632
                val = val ^ pred;
245
52632
                *coded_val = val;
246
            }
247
78948
            cbp |= val << (5 - i);
248
        }
249
    }
250
251
128046
    if (!s->mb_intra) {
252
        int mx, my;
253

109652
        if(s->per_mb_rl_table && cbp){
254
            s->rl_table_index = decode012(&s->gb);
255
            s->rl_chroma_table_index = s->rl_table_index;
256
        }
257
109652
        ff_h263_pred_motion(s, 0, 0, &mx, &my);
258
109652
        ff_msmpeg4_decode_motion(s, &mx, &my);
259
109652
        s->mv_dir = MV_DIR_FORWARD;
260
109652
        s->mv_type = MV_TYPE_16X16;
261
109652
        s->mv[0][0][0] = mx;
262
109652
        s->mv[0][0][1] = my;
263
109652
        *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
264
    } else {
265
        ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
266
                ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
267
                show_bits(&s->gb, 24));
268
18394
        s->ac_pred = get_bits1(&s->gb);
269
18394
        *mb_type_ptr = MB_TYPE_INTRA;
270
18394
        if(s->inter_intra_pred){
271
            s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
272
            ff_dlog(s, "%d%d %d %d/",
273
                    s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
274
        }
275

18394
        if(s->per_mb_rl_table && cbp){
276
            s->rl_table_index = decode012(&s->gb);
277
            s->rl_chroma_table_index = s->rl_table_index;
278
        }
279
    }
280
281
128046
    s->bdsp.clear_blocks(s->block[0]);
282
896322
    for (i = 0; i < 6; i++) {
283
768276
        if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
284
        {
285
            av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
286
            return -1;
287
        }
288
    }
289
290
128046
    return 0;
291
}
292
293
/* init all vlc decoding tables */
294
87
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
295
{
296
87
    MpegEncContext *s = avctx->priv_data;
297
    static volatile int done = 0;
298
    int i, ret;
299
    MVTable *mv;
300
301
87
    if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
302
        return ret;
303
304
87
    if (ff_h263_decode_init(avctx) < 0)
305
        return -1;
306
307
87
    ff_msmpeg4_common_init(s);
308
309
87
    if (!done) {
310
301
        for(i=0;i<NB_RL_TABLES;i++) {
311
258
            ff_rl_init(&ff_rl_table[i], ff_static_rl_table_store[i]);
312
        }
313
43
        INIT_FIRST_VLC_RL(ff_rl_table[0], 642);
314
43
        INIT_FIRST_VLC_RL(ff_rl_table[1], 1104);
315
43
        INIT_FIRST_VLC_RL(ff_rl_table[2], 554);
316

1419
        INIT_VLC_RL(ff_rl_table[3], 940);
317

1419
        INIT_VLC_RL(ff_rl_table[4], 962);
318
        /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been
319
         * initialized in ff_h263_decode_init() above. So just copy the VLCs. */
320
        av_assert1(ff_h263_rl_inter.rl_vlc[0]);
321
43
        memcpy(ff_rl_table[5].rl_vlc, ff_h263_rl_inter.rl_vlc, sizeof(ff_rl_table[5].rl_vlc));
322
323
43
        mv = &ff_mv_tables[0];
324
43
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, MSMPEG4_MV_TABLES_NB_ELEMS + 1,
325
                    mv->table_mv_bits, 1, 1,
326
                    mv->table_mv_code, 2, 2, 3714);
327
43
        mv = &ff_mv_tables[1];
328
43
        INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, MSMPEG4_MV_TABLES_NB_ELEMS + 1,
329
                    mv->table_mv_bits, 1, 1,
330
                    mv->table_mv_code, 2, 2, 2694);
331
332
43
        INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
333
                 &ff_table0_dc_lum[0][1], 8, 4,
334
                 &ff_table0_dc_lum[0][0], 8, 4, 1158);
335
43
        INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
336
                 &ff_table0_dc_chroma[0][1], 8, 4,
337
                 &ff_table0_dc_chroma[0][0], 8, 4, 1118);
338
43
        INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
339
                 &ff_table1_dc_lum[0][1], 8, 4,
340
                 &ff_table1_dc_lum[0][0], 8, 4, 1476);
341
43
        INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
342
                 &ff_table1_dc_chroma[0][1], 8, 4,
343
                 &ff_table1_dc_chroma[0][0], 8, 4, 1216);
344
345
43
        INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
346
                 &ff_v2_dc_lum_table[0][1], 8, 4,
347
                 &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
348
43
        INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
349
                 &ff_v2_dc_chroma_table[0][1], 8, 4,
350
                 &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
351
352
43
        INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
353
                 &ff_v2_intra_cbpc[0][1], 2, 1,
354
                 &ff_v2_intra_cbpc[0][0], 2, 1, 8);
355
43
        INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
356
                 &ff_v2_mb_type[0][1], 2, 1,
357
                 &ff_v2_mb_type[0][0], 2, 1, 128);
358
359
215
        for (unsigned i = 0, offset = 0; i < 4; i++) {
360
            static VLC_TYPE vlc_buf[1636 + 2648 + 1532 + 2488][2];
361
172
            ff_mb_non_intra_vlc[i].table           = &vlc_buf[offset];
362
172
            ff_mb_non_intra_vlc[i].table_allocated = FF_ARRAY_ELEMS(vlc_buf) - offset;
363
172
            init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
364
                     &ff_wmv2_inter_table[i][0][1], 8, 4,
365
                     &ff_wmv2_inter_table[i][0][0], 8, 4,
366
                     INIT_VLC_STATIC_OVERLONG);
367
172
            offset += ff_mb_non_intra_vlc[i].table_size;
368
        }
369
370
43
        INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
371
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
372
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
373
374
43
        INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
375
                 &ff_table_inter_intra[0][1], 2, 1,
376
                 &ff_table_inter_intra[0][0], 2, 1, 8);
377
43
        done = 1;
378
    }
379
380

87
    switch(s->msmpeg4_version){
381
11
    case 1:
382
    case 2:
383
11
        s->decode_mb= msmpeg4v12_decode_mb;
384
11
        break;
385
22
    case 3:
386
    case 4:
387
22
        s->decode_mb= msmpeg4v34_decode_mb;
388
22
        break;
389
12
    case 5:
390
        if (CONFIG_WMV2_DECODER)
391
12
            s->decode_mb= ff_wmv2_decode_mb;
392
    case 6:
393
        //FIXME + TODO VC1 decode mb
394
54
        break;
395
    }
396
397
87
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
398
399
87
    return 0;
400
}
401
402
675
int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
403
{
404
    int code;
405
406
    // at minimum one bit per macroblock is required at least in a valid frame,
407
    // we discard frames much smaller than this. Frames smaller than 1/8 of the
408
    // smallest "black/skip" frame generally contain not much recoverable content
409
    // while at the same time they have the highest computational requirements
410
    // per byte
411
675
    if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
412
        return AVERROR_INVALIDDATA;
413
414
675
    if(s->msmpeg4_version==1){
415
50
        int start_code = get_bits_long(&s->gb, 32);
416
50
        if(start_code!=0x00000100){
417
            av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
418
            return -1;
419
        }
420
421
50
        skip_bits(&s->gb, 5); // frame number */
422
    }
423
424
675
    s->pict_type = get_bits(&s->gb, 2) + 1;
425
675
    if (s->pict_type != AV_PICTURE_TYPE_I &&
426
611
        s->pict_type != AV_PICTURE_TYPE_P){
427
        av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
428
        return -1;
429
    }
430
675
    s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
431
675
    if(s->qscale==0){
432
        av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
433
        return -1;
434
    }
435
436
675
    if (s->pict_type == AV_PICTURE_TYPE_I) {
437
64
        code = get_bits(&s->gb, 5);
438
64
        if(s->msmpeg4_version==1){
439

1
            if(code==0 || code>s->mb_height){
440
                av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
441
                return -1;
442
            }
443
444
1
            s->slice_height = code;
445
        }else{
446
            /* 0x17: one slice, 0x18: two slices, ... */
447
63
            if (code < 0x17){
448
                av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
449
                return -1;
450
            }
451
452
63
            s->slice_height = s->mb_height / (code - 0x16);
453
        }
454
455

64
        switch(s->msmpeg4_version){
456
21
        case 1:
457
        case 2:
458
21
            s->rl_chroma_table_index = 2;
459
21
            s->rl_table_index = 2;
460
461
21
            s->dc_table_index = 0; //not used
462
21
            break;
463
23
        case 3:
464
23
            s->rl_chroma_table_index = decode012(&s->gb);
465
23
            s->rl_table_index = decode012(&s->gb);
466
467
23
            s->dc_table_index = get_bits1(&s->gb);
468
23
            break;
469
20
        case 4:
470
20
            ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
471
472
20
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
473
            else                           s->per_mb_rl_table= 0;
474
475
20
            if(!s->per_mb_rl_table){
476
20
                s->rl_chroma_table_index = decode012(&s->gb);
477
20
                s->rl_table_index = decode012(&s->gb);
478
            }
479
480
20
            s->dc_table_index = get_bits1(&s->gb);
481
20
            s->inter_intra_pred= 0;
482
20
            break;
483
        }
484
64
        s->no_rounding = 1;
485
64
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
486
            av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
487
                s->qscale,
488
                s->rl_chroma_table_index,
489
                s->rl_table_index,
490
                s->dc_table_index,
491
                s->per_mb_rl_table,
492
                s->slice_height);
493
    } else {
494

611
        switch(s->msmpeg4_version){
495
229
        case 1:
496
        case 2:
497
229
            if(s->msmpeg4_version==1)
498
49
                s->use_skip_mb_code = 1;
499
            else
500
180
                s->use_skip_mb_code = get_bits1(&s->gb);
501
229
            s->rl_table_index = 2;
502
229
            s->rl_chroma_table_index = s->rl_table_index;
503
229
            s->dc_table_index = 0; //not used
504
229
            s->mv_table_index = 0;
505
229
            break;
506
202
        case 3:
507
202
            s->use_skip_mb_code = get_bits1(&s->gb);
508
202
            s->rl_table_index = decode012(&s->gb);
509
202
            s->rl_chroma_table_index = s->rl_table_index;
510
511
202
            s->dc_table_index = get_bits1(&s->gb);
512
513
202
            s->mv_table_index = get_bits1(&s->gb);
514
202
            break;
515
180
        case 4:
516
180
            s->use_skip_mb_code = get_bits1(&s->gb);
517
518
180
            if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
519
            else                           s->per_mb_rl_table= 0;
520
521
180
            if(!s->per_mb_rl_table){
522
180
                s->rl_table_index = decode012(&s->gb);
523
180
                s->rl_chroma_table_index = s->rl_table_index;
524
            }
525
526
180
            s->dc_table_index = get_bits1(&s->gb);
527
528
180
            s->mv_table_index = get_bits1(&s->gb);
529

180
            s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
530
180
            break;
531
        }
532
533
611
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
534
            av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
535
                s->use_skip_mb_code,
536
                s->rl_table_index,
537
                s->rl_chroma_table_index,
538
                s->dc_table_index,
539
                s->mv_table_index,
540
                s->per_mb_rl_table,
541
                s->qscale);
542
543
611
        if(s->flipflop_rounding){
544
382
            s->no_rounding ^= 1;
545
        }else{
546
229
            s->no_rounding = 0;
547
        }
548
    }
549
    ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
550
            s->inter_intra_pred, s->width, s->height);
551
552
675
    s->esc3_level_length= 0;
553
675
    s->esc3_run_length= 0;
554
555
675
    return 0;
556
}
557
558
64
int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
559
{
560
64
    int left= buf_size*8 - get_bits_count(&s->gb);
561
64
    int length= s->msmpeg4_version>=3 ? 17 : 16;
562
    /* the alt_bitstream reader could read over the end so we need to check it */
563

64
    if(left>=length && left<length+8)
564
    {
565
63
        skip_bits(&s->gb, 5); /* fps */
566
63
        s->bit_rate= get_bits(&s->gb, 11)*1024;
567
63
        if(s->msmpeg4_version>=3)
568
43
            s->flipflop_rounding= get_bits1(&s->gb);
569
        else
570
20
            s->flipflop_rounding= 0;
571
    }
572
1
    else if(left<length+8)
573
    {
574
1
        s->flipflop_rounding= 0;
575
1
        if(s->msmpeg4_version != 2)
576
1
            av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
577
    }
578
    else
579
    {
580
        av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
581
    }
582
583
64
    return 0;
584
}
585
586
230712
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
587
{
588
    int level, pred;
589
590
230712
    if(s->msmpeg4_version<=2){
591
54342
        if (n < 4) {
592
36228
            level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
593
        } else {
594
18114
            level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
595
        }
596
54342
        if (level < 0) {
597
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
598
            *dir_ptr = 0;
599
            return -1;
600
        }
601
54342
        level-=256;
602
    }else{  //FIXME optimize use unified tables & index
603
176370
        if (n < 4) {
604
117580
            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
605
        } else {
606
58790
            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
607
        }
608
609
176370
        if (level == DC_MAX) {
610
48
            level = get_bits(&s->gb, 8);
611
48
            if (get_bits1(&s->gb))
612
6
                level = -level;
613
176322
        } else if (level != 0) {
614
153813
            if (get_bits1(&s->gb))
615
74512
                level = -level;
616
        }
617
    }
618
619
230712
    if(s->msmpeg4_version==1){
620
        int32_t *dc_val;
621
5490
        pred = msmpeg4v1_pred_dc(s, n, &dc_val);
622
5490
        level += pred;
623
624
        /* update predictor */
625
5490
        *dc_val= level;
626
    }else{
627
        int16_t *dc_val;
628
225222
        pred   = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
629
225222
        level += pred;
630
631
        /* update predictor */
632
225222
        if (n < 4) {
633
150148
            *dc_val = level * s->y_dc_scale;
634
        } else {
635
75074
            *dc_val = level * s->c_dc_scale;
636
        }
637
    }
638
639
230712
    return level;
640
}
641
642
1472610
int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block,
643
                              int n, int coded, const uint8_t *scan_table)
644
{
645
    int level, i, last, run, run_diff;
646
1472610
    int av_uninit(dc_pred_dir);
647
    RLTable *rl;
648
    RL_VLC_ELEM *rl_vlc;
649
    int qmul, qadd;
650
651
1472610
    if (s->mb_intra) {
652
230712
        qmul=1;
653
230712
        qadd=0;
654
655
        /* DC coef */
656
230712
        level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
657
658
230712
        if (level < 0){
659
            av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
660
            if(s->inter_intra_pred) level=0;
661
        }
662
230712
        if (n < 4) {
663
153808
            rl = &ff_rl_table[s->rl_table_index];
664
153808
            if(level > 256*s->y_dc_scale){
665
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
666
                if(!s->inter_intra_pred) return -1;
667
            }
668
        } else {
669
76904
            rl = &ff_rl_table[3 + s->rl_chroma_table_index];
670
76904
            if(level > 256*s->c_dc_scale){
671
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
672
                if(!s->inter_intra_pred) return -1;
673
            }
674
        }
675
230712
        block[0] = level;
676
677
230712
        run_diff = s->msmpeg4_version >= 4;
678
230712
        i = 0;
679
230712
        if (!coded) {
680
42456
            goto not_coded;
681
        }
682
188256
        if (s->ac_pred) {
683
3224
            if (dc_pred_dir == 0)
684
1928
                scan_table = s->intra_v_scantable.permutated; /* left */
685
            else
686
1296
                scan_table = s->intra_h_scantable.permutated; /* top */
687
        } else {
688
185032
            scan_table = s->intra_scantable.permutated;
689
        }
690
188256
        rl_vlc= rl->rl_vlc[0];
691
    } else {
692
1241898
        qmul = s->qscale << 1;
693
1241898
        qadd = (s->qscale - 1) | 1;
694
1241898
        i = -1;
695
1241898
        rl = &ff_rl_table[3 + s->rl_table_index];
696
697
1241898
        if(s->msmpeg4_version==2)
698
306018
            run_diff = 0;
699
        else
700
935880
            run_diff = 1;
701
702
1241898
        if (!coded) {
703
633723
            s->block_last_index[n] = i;
704
633723
            return 0;
705
        }
706
608175
        if(!scan_table)
707
420993
            scan_table = s->inter_scantable.permutated;
708
608175
        rl_vlc= rl->rl_vlc[s->qscale];
709
    }
710
  {
711
796431
    OPEN_READER(re, &s->gb);
712
    for(;;) {
713
4986167
        UPDATE_CACHE(re, &s->gb);
714
4986167
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
715
4986167
        if (level==0) {
716
            int cache;
717
162066
            cache= GET_CACHE(re, &s->gb);
718
            /* escape */
719

162066
            if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
720

96392
                if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
721
                    /* third escape */
722
41550
                    if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
723
41550
                    UPDATE_CACHE(re, &s->gb);
724
41550
                    if(s->msmpeg4_version<=3){
725
34734
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
726
34734
                        run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
727
34734
                        level= SHOW_SBITS(re, &s->gb, 8);
728
34734
                        SKIP_COUNTER(re, &s->gb, 1+6+8);
729
                    }else{
730
                        int sign;
731
6816
                        last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
732
6816
                        if(!s->esc3_level_length){
733
                            int ll;
734
                            ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
735
                                    show_bits(&s->gb, 24), s->mb_x, s->mb_y);
736
384
                            if(s->qscale<8){
737
78
                                ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
738
78
                                if(ll==0){
739
                                    ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
740
                                }
741
                            }else{
742
306
                                ll=2;
743

2014
                                while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
744
1708
                                    ll++;
745
1708
                                    SKIP_BITS(re, &s->gb, 1);
746
                                }
747
306
                                if(ll<8) SKIP_BITS(re, &s->gb, 1);
748
                            }
749
750
384
                            s->esc3_level_length= ll;
751
384
                            s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
752
384
                            UPDATE_CACHE(re, &s->gb);
753
                        }
754
6816
                        run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
755
6816
                        SKIP_BITS(re, &s->gb, s->esc3_run_length);
756
757
6816
                        sign=  SHOW_UBITS(re, &s->gb, 1);
758
6816
                        SKIP_BITS(re, &s->gb, 1);
759
760
6816
                        level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
761
6816
                        SKIP_BITS(re, &s->gb, s->esc3_level_length);
762
6816
                        if(sign) level= -level;
763
                    }
764
765
                    //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
766
41550
                    if (level>0) level= level * qmul + qadd;
767
20607
                    else         level= level * qmul - qadd;
768
41550
                    i+= run + 1;
769
41550
                    if(last) i+=192;
770
                } else {
771
                    /* second escape */
772
54842
                    SKIP_BITS(re, &s->gb, 2);
773
54842
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
774
54842
                    i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
775
54842
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
776
54842
                    LAST_SKIP_BITS(re, &s->gb, 1);
777
                }
778
            } else {
779
                /* first escape */
780
65674
                SKIP_BITS(re, &s->gb, 1);
781
65674
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
782
65674
                i+= run;
783
65674
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
784
65674
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
785
65674
                LAST_SKIP_BITS(re, &s->gb, 1);
786
            }
787
        } else {
788
4824101
            i+= run;
789
4824101
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
790
4824101
            LAST_SKIP_BITS(re, &s->gb, 1);
791
        }
792
4986167
        if (i > 62){
793
796431
            i-= 192;
794
796431
            if(i&(~63)){
795
                const int left= get_bits_left(&s->gb);
796
                if (((i + 192 == 64 && level / qmul == -1) ||
797
                     !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
798
                    left >= 0) {
799
                    av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
800
                    i = 63;
801
                    break;
802
                }else{
803
                    av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
804
                    return -1;
805
                }
806
            }
807
808
796431
            block[scan_table[i]] = level;
809
796431
            break;
810
        }
811
812
4189736
        block[scan_table[i]] = level;
813
    }
814
796431
    CLOSE_READER(re, &s->gb);
815
  }
816
838887
 not_coded:
817
838887
    if (s->mb_intra) {
818
230712
        ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
819
230712
        if (s->ac_pred) {
820
4194
            i = 63; /* XXX: not optimal */
821
        }
822
    }
823

838887
    if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
824
838887
    s->block_last_index[n] = i;
825
826
838887
    return 0;
827
}
828
829
228076
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
830
{
831
    MVTable *mv;
832
    int code, mx, my;
833
834
228076
    mv = &ff_mv_tables[s->mv_table_index];
835
836
228076
    code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
837
228076
    if (code == MSMPEG4_MV_TABLES_NB_ELEMS) {
838
1856
        mx = get_bits(&s->gb, 6);
839
1856
        my = get_bits(&s->gb, 6);
840
    } else {
841
226220
        mx = mv->table_mvx[code];
842
226220
        my = mv->table_mvy[code];
843
    }
844
845
228076
    mx += *mx_ptr - 32;
846
228076
    my += *my_ptr - 32;
847
    /* WARNING : they do not do exactly modulo encoding */
848
228076
    if (mx <= -64)
849
22
        mx += 64;
850
228054
    else if (mx >= 64)
851
10
        mx -= 64;
852
853
228076
    if (my <= -64)
854
6
        my += 64;
855
228070
    else if (my >= 64)
856
4
        my -= 64;
857
228076
    *mx_ptr = mx;
858
228076
    *my_ptr = my;
859
228076
}
860
861
AVCodec ff_msmpeg4v1_decoder = {
862
    .name           = "msmpeg4v1",
863
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
864
    .type           = AVMEDIA_TYPE_VIDEO,
865
    .id             = AV_CODEC_ID_MSMPEG4V1,
866
    .priv_data_size = sizeof(MpegEncContext),
867
    .init           = ff_msmpeg4_decode_init,
868
    .close          = ff_h263_decode_end,
869
    .decode         = ff_h263_decode_frame,
870
    .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
871
    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
872
    .max_lowres     = 3,
873
    .pix_fmts       = (const enum AVPixelFormat[]) {
874
        AV_PIX_FMT_YUV420P,
875
        AV_PIX_FMT_NONE
876
    },
877
};
878
879
AVCodec ff_msmpeg4v2_decoder = {
880
    .name           = "msmpeg4v2",
881
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
882
    .type           = AVMEDIA_TYPE_VIDEO,
883
    .id             = AV_CODEC_ID_MSMPEG4V2,
884
    .priv_data_size = sizeof(MpegEncContext),
885
    .init           = ff_msmpeg4_decode_init,
886
    .close          = ff_h263_decode_end,
887
    .decode         = ff_h263_decode_frame,
888
    .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
889
    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
890
    .max_lowres     = 3,
891
    .pix_fmts       = (const enum AVPixelFormat[]) {
892
        AV_PIX_FMT_YUV420P,
893
        AV_PIX_FMT_NONE
894
    },
895
};
896
897
AVCodec ff_msmpeg4v3_decoder = {
898
    .name           = "msmpeg4",
899
    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
900
    .type           = AVMEDIA_TYPE_VIDEO,
901
    .id             = AV_CODEC_ID_MSMPEG4V3,
902
    .priv_data_size = sizeof(MpegEncContext),
903
    .init           = ff_msmpeg4_decode_init,
904
    .close          = ff_h263_decode_end,
905
    .decode         = ff_h263_decode_frame,
906
    .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
907
    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
908
    .max_lowres     = 3,
909
    .pix_fmts       = (const enum AVPixelFormat[]) {
910
        AV_PIX_FMT_YUV420P,
911
        AV_PIX_FMT_NONE
912
    },
913
};
914
915
AVCodec ff_wmv1_decoder = {
916
    .name           = "wmv1",
917
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
918
    .type           = AVMEDIA_TYPE_VIDEO,
919
    .id             = AV_CODEC_ID_WMV1,
920
    .priv_data_size = sizeof(MpegEncContext),
921
    .init           = ff_msmpeg4_decode_init,
922
    .close          = ff_h263_decode_end,
923
    .decode         = ff_h263_decode_frame,
924
    .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
925
    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
926
    .max_lowres     = 3,
927
    .pix_fmts       = (const enum AVPixelFormat[]) {
928
        AV_PIX_FMT_YUV420P,
929
        AV_PIX_FMT_NONE
930
    },
931
};