GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ac3dsp.c Lines: 251 260 96.5 %
Date: 2019-11-22 03:34:36 Branches: 92 110 83.6 %

Line Branch Exec Source
1
/*
2
 * AC-3 DSP functions
3
 * Copyright (c) 2011 Justin Ruggles
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 "avcodec.h"
23
#include "ac3.h"
24
#include "ac3dsp.h"
25
#include "mathops.h"
26
27
6386
static void ac3_exponent_min_c(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
28
{
29
    int blk, i;
30
31
6386
    if (!num_reuse_blocks)
32
3991
        return;
33
34
615515
    for (i = 0; i < nb_coefs; i++) {
35
613120
        uint8_t min_exp = *exp;
36
613120
        uint8_t *exp1 = exp + 256;
37
2872064
        for (blk = 0; blk < num_reuse_blocks; blk++) {
38
2258944
            uint8_t next_exp = *exp1;
39
2258944
            if (next_exp < min_exp)
40
349729
                min_exp = next_exp;
41
2258944
            exp1 += 256;
42
        }
43
613120
        *exp++ = min_exp;
44
    }
45
}
46
47
4344
static int ac3_max_msb_abs_int16_c(const int16_t *src, int len)
48
{
49
4344
    int i, v = 0;
50
2228472
    for (i = 0; i < len; i++)
51
2224128
        v |= abs(src[i]);
52
4344
    return v;
53
}
54
55
3996
static void ac3_lshift_int16_c(int16_t *src, unsigned int len,
56
                               unsigned int shift)
57
{
58
3996
    uint32_t *src32 = (uint32_t *)src;
59
3996
    const uint32_t mask = ~(((1 << shift) - 1) << 16);
60
    int i;
61
3996
    len >>= 1;
62
131868
    for (i = 0; i < len; i += 8) {
63
127872
        src32[i  ] = (src32[i  ] << shift) & mask;
64
127872
        src32[i+1] = (src32[i+1] << shift) & mask;
65
127872
        src32[i+2] = (src32[i+2] << shift) & mask;
66
127872
        src32[i+3] = (src32[i+3] << shift) & mask;
67
127872
        src32[i+4] = (src32[i+4] << shift) & mask;
68
127872
        src32[i+5] = (src32[i+5] << shift) & mask;
69
127872
        src32[i+6] = (src32[i+6] << shift) & mask;
70
127872
        src32[i+7] = (src32[i+7] << shift) & mask;
71
    }
72
3996
}
73
74
139008
static void ac3_rshift_int32_c(int32_t *src, unsigned int len,
75
                               unsigned int shift)
76
{
77
    do {
78
139008
        *src++ >>= shift;
79
139008
        *src++ >>= shift;
80
139008
        *src++ >>= shift;
81
139008
        *src++ >>= shift;
82
139008
        *src++ >>= shift;
83
139008
        *src++ >>= shift;
84
139008
        *src++ >>= shift;
85
139008
        *src++ >>= shift;
86
139008
        len -= 8;
87
139008
    } while (len > 0);
88
4344
}
89
90
3822
static void float_to_fixed24_c(int32_t *dst, const float *src, unsigned int len)
91
{
92
3822
    const float scale = 1 << 24;
93
    do {
94
327600
        *dst++ = lrintf(*src++ * scale);
95
327600
        *dst++ = lrintf(*src++ * scale);
96
327600
        *dst++ = lrintf(*src++ * scale);
97
327600
        *dst++ = lrintf(*src++ * scale);
98
327600
        *dst++ = lrintf(*src++ * scale);
99
327600
        *dst++ = lrintf(*src++ * scale);
100
327600
        *dst++ = lrintf(*src++ * scale);
101
327600
        *dst++ = lrintf(*src++ * scale);
102
327600
        len -= 8;
103
327600
    } while (len > 0);
104
3822
}
105
106
67825
static void ac3_bit_alloc_calc_bap_c(int16_t *mask, int16_t *psd,
107
                                     int start, int end,
108
                                     int snr_offset, int floor,
109
                                     const uint8_t *bap_tab, uint8_t *bap)
110
{
111
    int bin, band, band_end;
112
113
    /* special case, if snr offset is -960, set all bap's to zero */
114
67825
    if (snr_offset == -960) {
115
        memset(bap, 0, AC3_MAX_COEFS);
116
        return;
117
    }
118
119
67825
    bin  = start;
120
67825
    band = ff_ac3_bin_to_band_tab[start];
121
    do {
122
2244943
        int m = (FFMAX(mask[band] - snr_offset - floor, 0) & 0x1FE0) + floor;
123
2244943
        band_end = ff_ac3_band_start_tab[++band];
124
2244943
        band_end = FFMIN(band_end, end);
125
126
10954702
        for (; bin < band_end; bin++) {
127
8709759
            int address = av_clip_uintp2((psd[bin] - m) >> 5, 6);
128
8709759
            bap[bin] = bap_tab[address];
129
        }
130
2244943
    } while (end > band_end);
131
}
132
133
127680
static void ac3_update_bap_counts_c(uint16_t mant_cnt[16], uint8_t *bap,
134
                                    int len)
135
{
136
13918836
    while (len-- > 0)
137
13791156
        mant_cnt[bap[len]]++;
138
127680
}
139
140
DECLARE_ALIGNED(16, const uint16_t, ff_ac3_bap_bits)[16] = {
141
    0,  0,  0,  3,  0,  4,  5,  6,  7,  8,  9, 10, 11, 12, 14, 16
142
};
143
144
9340
static int ac3_compute_mantissa_size_c(uint16_t mant_cnt[6][16])
145
{
146
    int blk, bap;
147
9340
    int bits = 0;
148
149
65380
    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
150
        // bap=1 : 3 mantissas in 5 bits
151
56040
        bits += (mant_cnt[blk][1] / 3) * 5;
152
        // bap=2 : 3 mantissas in 7 bits
153
        // bap=4 : 2 mantissas in 7 bits
154
56040
        bits += ((mant_cnt[blk][2] / 3) + (mant_cnt[blk][4] >> 1)) * 7;
155
        // bap=3 : 1 mantissa in 3 bits
156
56040
        bits += mant_cnt[blk][3] * 3;
157
        // bap=5 to 15 : get bits per mantissa from table
158
672480
        for (bap = 5; bap < 16; bap++)
159
616440
            bits += mant_cnt[blk][bap] * ff_ac3_bap_bits[bap];
160
    }
161
9340
    return bits;
162
}
163
164
5411
static void ac3_extract_exponents_c(uint8_t *exp, int32_t *coef, int nb_coefs)
165
{
166
    int i;
167
168
4037219
    for (i = 0; i < nb_coefs; i++) {
169
4031808
        int v = abs(coef[i]);
170
4031808
        exp[i] = v ? 23 - av_log2(v) : 24;
171
    }
172
5411
}
173
174
4152
static void ac3_sum_square_butterfly_int32_c(int64_t sum[4],
175
                                             const int32_t *coef0,
176
                                             const int32_t *coef1,
177
                                             int len)
178
{
179
    int i;
180
181
4152
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
182
183
91344
    for (i = 0; i < len; i++) {
184
87192
        int lt = coef0[i];
185
87192
        int rt = coef1[i];
186
87192
        int md = lt + rt;
187
87192
        int sd = lt - rt;
188
87192
        MAC64(sum[0], lt, lt);
189
87192
        MAC64(sum[1], rt, rt);
190
87192
        MAC64(sum[2], md, md);
191
87192
        MAC64(sum[3], sd, sd);
192
    }
193
4152
}
194
195
13104
static void ac3_sum_square_butterfly_float_c(float sum[4],
196
                                             const float *coef0,
197
                                             const float *coef1,
198
                                             int len)
199
{
200
    int i;
201
202
13104
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
203
204
288288
    for (i = 0; i < len; i++) {
205
275184
        float lt = coef0[i];
206
275184
        float rt = coef1[i];
207
275184
        float md = lt + rt;
208
275184
        float sd = lt - rt;
209
275184
        sum[0] += lt * lt;
210
275184
        sum[1] += rt * rt;
211
275184
        sum[2] += md * md;
212
275184
        sum[3] += sd * sd;
213
    }
214
13104
}
215
216
330
static void ac3_downmix_5_to_2_symmetric_c(float **samples, float **matrix,
217
                                           int len)
218
{
219
    int i;
220
    float v0, v1;
221
330
    float front_mix    = matrix[0][0];
222
330
    float center_mix   = matrix[0][1];
223
330
    float surround_mix = matrix[0][3];
224
225
84810
    for (i = 0; i < len; i++) {
226
84480
        v0 = samples[0][i] * front_mix  +
227
84480
             samples[1][i] * center_mix +
228
84480
             samples[3][i] * surround_mix;
229
230
84480
        v1 = samples[1][i] * center_mix +
231
84480
             samples[2][i] * front_mix  +
232
84480
             samples[4][i] * surround_mix;
233
234
84480
        samples[0][i] = v0;
235
84480
        samples[1][i] = v1;
236
    }
237
330
}
238
239
330
static void ac3_downmix_5_to_1_symmetric_c(float **samples, float **matrix,
240
                                           int len)
241
{
242
    int i;
243
330
    float front_mix    = matrix[0][0];
244
330
    float center_mix   = matrix[0][1];
245
330
    float surround_mix = matrix[0][3];
246
247
84810
    for (i = 0; i < len; i++) {
248
84480
        samples[0][i] = samples[0][i] * front_mix    +
249
84480
                        samples[1][i] * center_mix   +
250
84480
                        samples[2][i] * front_mix    +
251
84480
                        samples[3][i] * surround_mix +
252
84480
                        samples[4][i] * surround_mix;
253
    }
254
330
}
255
256
746
static void ac3_downmix_c(float **samples, float **matrix,
257
                          int out_ch, int in_ch, int len)
258
{
259
    int i, j;
260
    float v0, v1;
261
262
746
    if (out_ch == 2) {
263
95733
        for (i = 0; i < len; i++) {
264
95360
            v0 = v1 = 0.0f;
265
476800
            for (j = 0; j < in_ch; j++) {
266
381440
                v0 += samples[j][i] * matrix[0][j];
267
381440
                v1 += samples[j][i] * matrix[1][j];
268
            }
269
95360
            samples[0][i] = v0;
270
95360
            samples[1][i] = v1;
271
        }
272
373
    } else if (out_ch == 1) {
273
95733
        for (i = 0; i < len; i++) {
274
95360
            v0 = 0.0f;
275
476800
            for (j = 0; j < in_ch; j++)
276
381440
                v0 += samples[j][i] * matrix[0][j];
277
95360
            samples[0][i] = v0;
278
        }
279
    }
280
746
}
281
282
330
static void ac3_downmix_5_to_2_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
283
                                           int len)
284
{
285
    int i;
286
    int64_t v0, v1;
287
330
    int16_t front_mix    = matrix[0][0];
288
330
    int16_t center_mix   = matrix[0][1];
289
330
    int16_t surround_mix = matrix[0][3];
290
291
84810
    for (i = 0; i < len; i++) {
292
84480
        v0 = (int64_t)samples[0][i] * front_mix  +
293
84480
             (int64_t)samples[1][i] * center_mix +
294
84480
             (int64_t)samples[3][i] * surround_mix;
295
296
84480
        v1 = (int64_t)samples[1][i] * center_mix +
297
84480
             (int64_t)samples[2][i] * front_mix  +
298
84480
             (int64_t)samples[4][i] * surround_mix;
299
300
84480
        samples[0][i] = (v0+2048)>>12;
301
84480
        samples[1][i] = (v1+2048)>>12;
302
    }
303
330
}
304
305
330
static void ac3_downmix_5_to_1_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
306
                                                 int len)
307
{
308
    int i;
309
    int64_t v0;
310
330
    int16_t front_mix    = matrix[0][0];
311
330
    int16_t center_mix   = matrix[0][1];
312
330
    int16_t surround_mix = matrix[0][3];
313
314
84810
    for (i = 0; i < len; i++) {
315
84480
        v0 = (int64_t)samples[0][i] * front_mix    +
316
84480
             (int64_t)samples[1][i] * center_mix   +
317
84480
             (int64_t)samples[2][i] * front_mix    +
318
84480
             (int64_t)samples[3][i] * surround_mix +
319
84480
             (int64_t)samples[4][i] * surround_mix;
320
321
84480
        samples[0][i] = (v0+2048)>>12;
322
    }
323
330
}
324
325
372
static void ac3_downmix_c_fixed(int32_t **samples, int16_t **matrix,
326
                                int out_ch, int in_ch, int len)
327
{
328
    int i, j;
329
    int64_t v0, v1;
330
372
    if (out_ch == 2) {
331
        for (i = 0; i < len; i++) {
332
            v0 = v1 = 0;
333
            for (j = 0; j < in_ch; j++) {
334
                v0 += (int64_t)samples[j][i] * matrix[0][j];
335
                v1 += (int64_t)samples[j][i] * matrix[1][j];
336
            }
337
            samples[0][i] = (v0+2048)>>12;
338
            samples[1][i] = (v1+2048)>>12;
339
        }
340
372
    } else if (out_ch == 1) {
341
95476
        for (i = 0; i < len; i++) {
342
95104
            v0 = 0;
343
475520
            for (j = 0; j < in_ch; j++)
344
380416
                v0 += (int64_t)samples[j][i] * matrix[0][j];
345
95104
            samples[0][i] = (v0+2048)>>12;
346
        }
347
    }
348
372
}
349
350
1032
void ff_ac3dsp_downmix_fixed(AC3DSPContext *c, int32_t **samples, int16_t **matrix,
351
                             int out_ch, int in_ch, int len)
352
{
353

1032
    if (c->in_channels != in_ch || c->out_channels != out_ch) {
354
3
        c->in_channels  = in_ch;
355
3
        c->out_channels = out_ch;
356
3
        c->downmix_fixed = NULL;
357
358

3
        if (in_ch == 5 && out_ch == 2 &&
359
1
            !(matrix[1][0] | matrix[0][2]  |
360
1
              matrix[1][3] | matrix[0][4]  |
361
1
             (matrix[0][1] ^ matrix[1][1]) |
362
1
             (matrix[0][0] ^ matrix[1][2]))) {
363
1
            c->downmix_fixed = ac3_downmix_5_to_2_symmetric_c_fixed;
364

2
        } else if (in_ch == 5 && out_ch == 1 &&
365
1
                   matrix[0][0] == matrix[0][2] &&
366
1
                   matrix[0][3] == matrix[0][4]) {
367
1
            c->downmix_fixed = ac3_downmix_5_to_1_symmetric_c_fixed;
368
        }
369
    }
370
371
1032
    if (c->downmix_fixed)
372
660
        c->downmix_fixed(samples, matrix, len);
373
    else
374
372
        ac3_downmix_c_fixed(samples, matrix, out_ch, in_ch, len);
375
1032
}
376
377
4344
static void apply_window_int16_c(int16_t *output, const int16_t *input,
378
                                 const int16_t *window, unsigned int len)
379
{
380
    int i;
381
4344
    int len2 = len >> 1;
382
383
1116408
    for (i = 0; i < len2; i++) {
384
1112064
        int16_t w       = window[i];
385
1112064
        output[i]       = (MUL16(input[i],       w) + (1 << 14)) >> 15;
386
1112064
        output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
387
    }
388
4344
}
389
390
1406
void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix,
391
                       int out_ch, int in_ch, int len)
392
{
393

1406
    if (c->in_channels != in_ch || c->out_channels != out_ch) {
394
4
        int **matrix_cmp = (int **)matrix;
395
396
4
        c->in_channels  = in_ch;
397
4
        c->out_channels = out_ch;
398
4
        c->downmix      = NULL;
399
400

4
        if (in_ch == 5 && out_ch == 2 &&
401
1
            !(matrix_cmp[1][0] | matrix_cmp[0][2]   |
402
1
              matrix_cmp[1][3] | matrix_cmp[0][4]   |
403
1
             (matrix_cmp[0][1] ^ matrix_cmp[1][1]) |
404
1
             (matrix_cmp[0][0] ^ matrix_cmp[1][2]))) {
405
1
            c->downmix = ac3_downmix_5_to_2_symmetric_c;
406

3
        } else if (in_ch == 5 && out_ch == 1 &&
407
1
                   matrix_cmp[0][0] == matrix_cmp[0][2] &&
408
1
                   matrix_cmp[0][3] == matrix_cmp[0][4]) {
409
1
            c->downmix = ac3_downmix_5_to_1_symmetric_c;
410
        }
411
412
        if (ARCH_X86)
413
4
            ff_ac3dsp_set_downmix_x86(c);
414
    }
415
416
1406
    if (c->downmix)
417
660
        c->downmix(samples, matrix, len);
418
    else
419
746
        ac3_downmix_c(samples, matrix, out_ch, in_ch, len);
420
1406
}
421
422
58
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
423
{
424
58
    c->ac3_exponent_min = ac3_exponent_min_c;
425
58
    c->ac3_max_msb_abs_int16 = ac3_max_msb_abs_int16_c;
426
58
    c->ac3_lshift_int16 = ac3_lshift_int16_c;
427
58
    c->ac3_rshift_int32 = ac3_rshift_int32_c;
428
58
    c->float_to_fixed24 = float_to_fixed24_c;
429
58
    c->bit_alloc_calc_bap = ac3_bit_alloc_calc_bap_c;
430
58
    c->update_bap_counts = ac3_update_bap_counts_c;
431
58
    c->compute_mantissa_size = ac3_compute_mantissa_size_c;
432
58
    c->extract_exponents = ac3_extract_exponents_c;
433
58
    c->sum_square_butterfly_int32 = ac3_sum_square_butterfly_int32_c;
434
58
    c->sum_square_butterfly_float = ac3_sum_square_butterfly_float_c;
435
58
    c->in_channels           = 0;
436
58
    c->out_channels          = 0;
437
58
    c->downmix               = NULL;
438
58
    c->downmix_fixed         = NULL;
439
58
    c->apply_window_int16 = apply_window_int16_c;
440
441
    if (ARCH_ARM)
442
        ff_ac3dsp_init_arm(c, bit_exact);
443
    if (ARCH_X86)
444
58
        ff_ac3dsp_init_x86(c, bit_exact);
445
    if (ARCH_MIPS)
446
        ff_ac3dsp_init_mips(c, bit_exact);
447
58
}