GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/wma.c Lines: 220 258 85.3 %
Date: 2020-10-23 17:01:47 Branches: 125 166 75.3 %

Line Branch Exec Source
1
/*
2
 * WMA compatible codec
3
 * Copyright (c) 2002-2007 The FFmpeg Project
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#include "libavutil/attributes.h"
23
24
#include "avcodec.h"
25
#include "internal.h"
26
#include "sinewin.h"
27
#include "wma.h"
28
#include "wma_common.h"
29
#include "wma_freqs.h"
30
#include "wmadata.h"
31
32
/* XXX: use same run/length optimization as mpeg decoders */
33
// FIXME maybe split decode / encode or pass flag
34
32
static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table,
35
                                 float **plevel_table, uint16_t **pint_table,
36
                                 const CoefVLCTable *vlc_table)
37
{
38
32
    int n                        = vlc_table->n;
39
32
    const uint8_t  *table_bits   = vlc_table->huffbits;
40
32
    const uint32_t *table_codes  = vlc_table->huffcodes;
41
32
    const uint16_t *levels_table = vlc_table->levels;
42
    uint16_t *run_table, *int_table;
43
    float *flevel_table;
44
    int i, l, j, k, level;
45
46
32
    init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
47
48
32
    run_table    = av_malloc_array(n, sizeof(uint16_t));
49
32
    flevel_table = av_malloc_array(n, sizeof(*flevel_table));
50
32
    int_table    = av_malloc_array(n, sizeof(uint16_t));
51

32
    if (!run_table || !flevel_table || !int_table) {
52
        av_freep(&run_table);
53
        av_freep(&flevel_table);
54
        av_freep(&int_table);
55
        return AVERROR(ENOMEM);
56
    }
57
32
    i            = 2;
58
32
    level        = 1;
59
32
    k            = 0;
60
2612
    while (i < n) {
61
2580
        int_table[k] = i;
62
2580
        l            = levels_table[k++];
63
20086
        for (j = 0; j < l; j++) {
64
17506
            run_table[i]    = j;
65
17506
            flevel_table[i] = level;
66
17506
            i++;
67
        }
68
2580
        level++;
69
    }
70
32
    *prun_table   = run_table;
71
32
    *plevel_table = flevel_table;
72
32
    *pint_table   = int_table;
73
74
32
    return 0;
75
}
76
77
16
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
78
{
79
16
    WMACodecContext *s = avctx->priv_data;
80
    int i, ret;
81
    float bps1, high_freq;
82
    volatile float bps;
83
    int sample_rate1;
84
    int coef_vlc_table;
85
86

16
    if (avctx->sample_rate <= 0 || avctx->sample_rate > 50000 ||
87

16
        avctx->channels    <= 0 || avctx->channels    > 2     ||
88
16
        avctx->bit_rate    <= 0)
89
        return -1;
90
91
92
16
    if (avctx->codec->id == AV_CODEC_ID_WMAV1)
93
3
        s->version = 1;
94
    else
95
13
        s->version = 2;
96
97
    /* compute MDCT block size */
98
16
    s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,
99
                                                  s->version, 0);
100
16
    s->next_block_len_bits = s->frame_len_bits;
101
16
    s->prev_block_len_bits = s->frame_len_bits;
102
16
    s->block_len_bits      = s->frame_len_bits;
103
104
16
    s->frame_len = 1 << s->frame_len_bits;
105
16
    if (s->use_variable_block_len) {
106
        int nb_max, nb;
107
7
        nb = ((flags2 >> 3) & 3) + 1;
108
7
        if ((avctx->bit_rate / avctx->channels) >= 32000)
109
4
            nb += 2;
110
7
        nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
111
7
        if (nb > nb_max)
112
            nb = nb_max;
113
7
        s->nb_block_sizes = nb + 1;
114
    } else
115
9
        s->nb_block_sizes = 1;
116
117
    /* init rate dependent parameters */
118
16
    s->use_noise_coding = 1;
119
16
    high_freq           = avctx->sample_rate * 0.5;
120
121
    /* if version 2, then the rates are normalized */
122
16
    sample_rate1 = avctx->sample_rate;
123
16
    if (s->version == 2) {
124
13
        if (sample_rate1 >= 44100)
125
10
            sample_rate1 = 44100;
126
3
        else if (sample_rate1 >= 22050)
127
            sample_rate1 = 22050;
128
3
        else if (sample_rate1 >= 16000)
129
1
            sample_rate1 = 16000;
130
2
        else if (sample_rate1 >= 11025)
131
            sample_rate1 = 11025;
132
2
        else if (sample_rate1 >= 8000)
133
2
            sample_rate1 = 8000;
134
    }
135
136
16
    bps                 = (float) avctx->bit_rate /
137
16
                          (float) (avctx->channels * avctx->sample_rate);
138
16
    s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;
139
16
    if (s->byte_offset_bits + 3 > MIN_CACHE_BITS) {
140
        av_log(avctx, AV_LOG_ERROR, "byte_offset_bits %d is too large\n", s->byte_offset_bits);
141
        return AVERROR_PATCHWELCOME;
142
    }
143
144
    /* compute high frequency value and choose if noise coding should
145
     * be activated */
146
16
    bps1 = bps;
147
16
    if (avctx->channels == 2)
148
12
        bps1 = bps * 1.6;
149
16
    if (sample_rate1 == 44100) {
150
13
        if (bps1 >= 0.61)
151
13
            s->use_noise_coding = 0;
152
        else
153
            high_freq = high_freq * 0.4;
154
3
    } else if (sample_rate1 == 22050) {
155
        if (bps1 >= 1.16)
156
            s->use_noise_coding = 0;
157
        else if (bps1 >= 0.72)
158
            high_freq = high_freq * 0.7;
159
        else
160
            high_freq = high_freq * 0.6;
161
3
    } else if (sample_rate1 == 16000) {
162
1
        if (bps > 0.5)
163
1
            high_freq = high_freq * 0.5;
164
        else
165
            high_freq = high_freq * 0.3;
166
2
    } else if (sample_rate1 == 11025)
167
        high_freq = high_freq * 0.7;
168
2
    else if (sample_rate1 == 8000) {
169
2
        if (bps <= 0.625)
170
1
            high_freq = high_freq * 0.5;
171
1
        else if (bps > 0.75)
172
1
            s->use_noise_coding = 0;
173
        else
174
            high_freq = high_freq * 0.65;
175
    } else {
176
        if (bps >= 0.8)
177
            high_freq = high_freq * 0.75;
178
        else if (bps >= 0.6)
179
            high_freq = high_freq * 0.6;
180
        else
181
            high_freq = high_freq * 0.5;
182
    }
183
    ff_dlog(s->avctx, "flags2=0x%x\n", flags2);
184
    ff_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%"PRId64" block_align=%d\n",
185
            s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate,
186
            avctx->block_align);
187
    ff_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
188
            bps, bps1, high_freq, s->byte_offset_bits);
189
    ff_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
190
            s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
191
192
    /* compute the scale factor band sizes for each MDCT block size */
193
    {
194
        int a, b, pos, lpos, k, block_len, i, j, n;
195
        const uint8_t *table;
196
197
16
        if (s->version == 1)
198
3
            s->coefs_start = 3;
199
        else
200
13
            s->coefs_start = 0;
201
55
        for (k = 0; k < s->nb_block_sizes; k++) {
202
39
            block_len = s->frame_len >> k;
203
204
39
            if (s->version == 1) {
205
3
                lpos = 0;
206
75
                for (i = 0; i < 25; i++) {
207
75
                    a   = ff_wma_critical_freqs[i];
208
75
                    b   = avctx->sample_rate;
209
75
                    pos = ((block_len * 2 * a) + (b >> 1)) / b;
210
75
                    if (pos > block_len)
211
3
                        pos = block_len;
212
75
                    s->exponent_bands[0][i] = pos - lpos;
213
75
                    if (pos >= block_len) {
214
3
                        i++;
215
3
                        break;
216
                    }
217
72
                    lpos = pos;
218
                }
219
3
                s->exponent_sizes[0] = i;
220
            } else {
221
                /* hardcoded tables */
222
36
                table = NULL;
223
36
                a     = s->frame_len_bits - BLOCK_MIN_BITS - k;
224
36
                if (a < 3) {
225
21
                    if (avctx->sample_rate >= 44100)
226
15
                        table = exponent_band_44100[a];
227
6
                    else if (avctx->sample_rate >= 32000)
228
                        table = exponent_band_32000[a];
229
6
                    else if (avctx->sample_rate >= 22050)
230
                        table = exponent_band_22050[a];
231
                }
232
36
                if (table) {
233
15
                    n = *table++;
234
235
                    for (i = 0; i < n; i++)
235
220
                        s->exponent_bands[k][i] = table[i];
236
15
                    s->exponent_sizes[k] = n;
237
                } else {
238
21
                    j    = 0;
239
21
                    lpos = 0;
240
495
                    for (i = 0; i < 25; i++) {
241
495
                        a     = ff_wma_critical_freqs[i];
242
495
                        b     = avctx->sample_rate;
243
495
                        pos   = ((block_len * 2 * a) + (b << 1)) / (4 * b);
244
495
                        pos <<= 2;
245
495
                        if (pos > block_len)
246
21
                            pos = block_len;
247
495
                        if (pos > lpos)
248
489
                            s->exponent_bands[k][j++] = pos - lpos;
249
495
                        if (pos >= block_len)
250
21
                            break;
251
474
                        lpos = pos;
252
                    }
253
21
                    s->exponent_sizes[k] = j;
254
                }
255
            }
256
257
            /* max number of coefs */
258
39
            s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
259
            /* high freq computation */
260
39
            s->high_band_start[k] = (int) ((block_len * 2 * high_freq) /
261
39
                                           avctx->sample_rate + 0.5);
262
39
            n   = s->exponent_sizes[k];
263
39
            j   = 0;
264
39
            pos = 0;
265
823
            for (i = 0; i < n; i++) {
266
                int start, end;
267
784
                start = pos;
268
784
                pos  += s->exponent_bands[k][i];
269
784
                end   = pos;
270
784
                if (start < s->high_band_start[k])
271
767
                    start = s->high_band_start[k];
272
784
                if (end > s->coefs_end[k])
273
45
                    end = s->coefs_end[k];
274
784
                if (end > start)
275
16
                    s->exponent_high_bands[k][j++] = end - start;
276
            }
277
39
            s->exponent_high_sizes[k] = j;
278
        }
279
    }
280
281
#ifdef TRACE
282
    {
283
        int i, j;
284
        for (i = 0; i < s->nb_block_sizes; i++) {
285
            ff_tlog(s->avctx, "%5d: n=%2d:",
286
                    s->frame_len >> i,
287
                    s->exponent_sizes[i]);
288
            for (j = 0; j < s->exponent_sizes[i]; j++)
289
                ff_tlog(s->avctx, " %d", s->exponent_bands[i][j]);
290
            ff_tlog(s->avctx, "\n");
291
        }
292
    }
293
#endif /* TRACE */
294
295
    /* init MDCT windows : simple sine window */
296
55
    for (i = 0; i < s->nb_block_sizes; i++) {
297
39
        ff_init_ff_sine_windows(s->frame_len_bits - i);
298
39
        s->windows[i] = ff_sine_windows[s->frame_len_bits - i];
299
    }
300
301
16
    s->reset_block_lengths = 1;
302
303
16
    if (s->use_noise_coding) {
304
        /* init the noise generator */
305
2
        if (s->use_exp_vlc)
306
            s->noise_mult = 0.02;
307
        else
308
2
            s->noise_mult = 0.04;
309
310
#ifdef TRACE
311
        for (i = 0; i < NOISE_TAB_SIZE; i++)
312
            s->noise_table[i] = 1.0 * s->noise_mult;
313
#else
314
        {
315
            unsigned int seed;
316
            float norm;
317
2
            seed = 1;
318
2
            norm = (1.0 / (float) (1LL << 31)) * sqrt(3) * s->noise_mult;
319
16386
            for (i = 0; i < NOISE_TAB_SIZE; i++) {
320
16384
                seed              = seed * 314159 + 1;
321
16384
                s->noise_table[i] = (float) ((int) seed) * norm;
322
            }
323
        }
324
#endif /* TRACE */
325
    }
326
327
16
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
328
16
    if (!s->fdsp)
329
        return AVERROR(ENOMEM);
330
331
    /* choose the VLC tables for the coefficients */
332
16
    coef_vlc_table = 2;
333
16
    if (avctx->sample_rate >= 32000) {
334
13
        if (bps1 < 0.72)
335
            coef_vlc_table = 0;
336
13
        else if (bps1 < 1.16)
337
2
            coef_vlc_table = 1;
338
    }
339
16
    s->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];
340
16
    s->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];
341
16
    ret = init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
342
                        &s->int_table[0], s->coef_vlcs[0]);
343
16
    if (ret < 0)
344
        return ret;
345
346
16
    return init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
347
                         &s->int_table[1], s->coef_vlcs[1]);
348
}
349
350
3650
int ff_wma_total_gain_to_bits(int total_gain)
351
{
352
3650
    if (total_gain < 15)
353
        return 13;
354
3650
    else if (total_gain < 32)
355
98
        return 12;
356
3552
    else if (total_gain < 40)
357
284
        return 11;
358
3268
    else if (total_gain < 45)
359
18
        return 10;
360
    else
361
3250
        return  9;
362
}
363
364
16
int ff_wma_end(AVCodecContext *avctx)
365
{
366
16
    WMACodecContext *s = avctx->priv_data;
367
    int i;
368
369
55
    for (i = 0; i < s->nb_block_sizes; i++)
370
39
        ff_mdct_end(&s->mdct_ctx[i]);
371
372
16
    if (s->use_exp_vlc)
373
13
        ff_free_vlc(&s->exp_vlc);
374
16
    if (s->use_noise_coding)
375
2
        ff_free_vlc(&s->hgain_vlc);
376
48
    for (i = 0; i < 2; i++) {
377
32
        ff_free_vlc(&s->coef_vlc[i]);
378
32
        av_freep(&s->run_table[i]);
379
32
        av_freep(&s->level_table[i]);
380
32
        av_freep(&s->int_table[i]);
381
    }
382
16
    av_freep(&s->fdsp);
383
384
16
    return 0;
385
}
386
387
/**
388
 * Decode an uncompressed coefficient.
389
 * @param gb GetBitContext
390
 * @return the decoded coefficient
391
 */
392
3915
unsigned int ff_wma_get_large_val(GetBitContext *gb)
393
{
394
    /** consumes up to 34 bits */
395
3915
    int n_bits = 8;
396
    /** decode length */
397
3915
    if (get_bits1(gb)) {
398
530
        n_bits += 8;
399
530
        if (get_bits1(gb)) {
400
            n_bits += 8;
401
            if (get_bits1(gb))
402
                n_bits += 7;
403
        }
404
    }
405
3915
    return get_bits_long(gb, n_bits);
406
}
407
408
/**
409
 * Decode run level compressed coefficients.
410
 * @param avctx codec context
411
 * @param gb bitstream reader context
412
 * @param vlc vlc table for get_vlc2
413
 * @param level_table level codes
414
 * @param run_table run codes
415
 * @param version 0 for wma1,2 1 for wmapro
416
 * @param ptr output buffer
417
 * @param offset offset in the output buffer
418
 * @param num_coefs number of input coefficients
419
 * @param block_len input buffer length (2^n)
420
 * @param frame_len_bits number of bits for escaped run codes
421
 * @param coef_nb_bits number of bits for escaped level codes
422
 * @return 0 on success, -1 otherwise
423
 */
424
2174
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb,
425
                            VLC *vlc, const float *level_table,
426
                            const uint16_t *run_table, int version,
427
                            WMACoef *ptr, int offset, int num_coefs,
428
                            int block_len, int frame_len_bits,
429
                            int coef_nb_bits)
430
{
431
    int code, level, sign;
432
2174
    const uint32_t *ilvl = (const uint32_t *) level_table;
433
2174
    uint32_t *iptr = (uint32_t *) ptr;
434
2174
    const unsigned int coef_mask = block_len - 1;
435
592299
    for (; offset < num_coefs; offset++) {
436
592287
        code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX);
437
592287
        if (code > 1) {
438
            /** normal code */
439
586557
            offset                  += run_table[code];
440
586557
            sign                     = get_bits1(gb) - 1;
441
586557
            iptr[offset & coef_mask] = ilvl[code] ^ (sign & 0x80000000);
442
5730
        } else if (code == 1) {
443
            /** EOB */
444
2162
            break;
445
        } else {
446
            /** escape */
447
3568
            if (!version) {
448
2926
                level = get_bits(gb, coef_nb_bits);
449
                /** NOTE: this is rather suboptimal. reading
450
                 *  block_len_bits would be better */
451
2926
                offset += get_bits(gb, frame_len_bits);
452
            } else {
453
642
                level = ff_wma_get_large_val(gb);
454
                /** escape decode */
455
642
                if (get_bits1(gb)) {
456
321
                    if (get_bits1(gb)) {
457
263
                        if (get_bits1(gb)) {
458
                            av_log(avctx, AV_LOG_ERROR,
459
                                   "broken escape sequence\n");
460
                            return -1;
461
                        } else
462
263
                            offset += get_bits(gb, frame_len_bits) + 4;
463
                    } else
464
58
                        offset += get_bits(gb, 2) + 1;
465
                }
466
            }
467
3568
            sign                    = get_bits1(gb) - 1;
468
3568
            ptr[offset & coef_mask] = (level ^ sign) - sign;
469
        }
470
    }
471
    /** NOTE: EOB can be omitted */
472
2174
    if (offset > num_coefs) {
473
        av_log(avctx, AV_LOG_ERROR,
474
               "overflow (%d > %d) in spectral RLE, ignoring\n",
475
               offset,
476
               num_coefs
477
              );
478
        return -1;
479
    }
480
481
2174
    return 0;
482
}