GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aacsbr.c Lines: 186 190 97.9 %
Date: 2019-11-20 04:07:19 Branches: 121 124 97.6 %

Line Branch Exec Source
1
/*
2
 * AAC Spectral Band Replication decoding functions
3
 * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
4
 * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * AAC Spectral Band Replication decoding functions
26
 * @author Robert Swain ( rob opendot cl )
27
 */
28
#define USE_FIXED 0
29
30
#include "aac.h"
31
#include "sbr.h"
32
#include "aacsbr.h"
33
#include "aacsbrdata.h"
34
#include "aacsbr_tablegen.h"
35
#include "fft.h"
36
#include "internal.h"
37
#include "aacps.h"
38
#include "sbrdsp.h"
39
#include "libavutil/internal.h"
40
#include "libavutil/libm.h"
41
#include "libavutil/avassert.h"
42
43
#include <stdint.h>
44
#include <float.h>
45
#include <math.h>
46
47
#if ARCH_MIPS
48
#include "mips/aacsbr_mips.h"
49
#endif /* ARCH_MIPS */
50
51
static VLC vlc_sbr[10];
52
static void aacsbr_func_ptr_init(AACSBRContext *c);
53
54
116
static void make_bands(int16_t* bands, int start, int stop, int num_bands)
55
{
56
    int k, previous, present;
57
    float base, prod;
58
59
116
    base = powf((float)stop / start, 1.0f / num_bands);
60
116
    prod = start;
61
116
    previous = start;
62
63
1310
    for (k = 0; k < num_bands-1; k++) {
64
1194
        prod *= base;
65
1194
        present  = lrintf(prod);
66
1194
        bands[k] = present - previous;
67
1194
        previous = present;
68
    }
69
116
    bands[num_bands-1] = stop - previous;
70
116
}
71
72
/// Dequantization and stereo decoding (14496-3 sp04 p203)
73
4450
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
74
{
75
    int k, e;
76
    int ch;
77
    static const double exp2_tab[2] = {1, M_SQRT2};
78

5795
    if (id_aac == TYPE_CPE && sbr->bs_coupling) {
79
1345
        int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
80
3103
        for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
81
20143
            for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
82
                float temp1, temp2, fac;
83
18385
                if (sbr->data[0].bs_amp_res) {
84
7387
                    temp1 = ff_exp2fi(sbr->data[0].env_facs_q[e][k] + 7);
85
7387
                    temp2 = ff_exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]);
86
                }
87
                else {
88
10998
                    temp1 = ff_exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) *
89
10998
                            exp2_tab[sbr->data[0].env_facs_q[e][k] & 1];
90
10998
                    temp2 = ff_exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) *
91
10998
                            exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1];
92
                }
93
18385
                if (temp1 > 1E20) {
94
                    av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
95
                    temp1 = 1;
96
                }
97
18385
                fac   = temp1 / (1.0f + temp2);
98
18385
                sbr->data[0].env_facs[e][k] = fac;
99
18385
                sbr->data[1].env_facs[e][k] = fac * temp2;
100
            }
101
        }
102
2995
        for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
103
6017
            for (k = 0; k < sbr->n_q; k++) {
104
4367
                float temp1 = ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1);
105
4367
                float temp2 = ff_exp2fi(12 - sbr->data[1].noise_facs_q[e][k]);
106
                float fac;
107
4367
                av_assert0(temp1 <= 1E20);
108
4367
                fac = temp1 / (1.0f + temp2);
109
4367
                sbr->data[0].noise_facs[e][k] = fac;
110
4367
                sbr->data[1].noise_facs[e][k] = fac * temp2;
111
            }
112
        }
113
    } else { // SCE or one non-coupled CPE
114

7046
        for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
115
9997
            for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
116
82225
                for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
117
76169
                    if (sbr->data[ch].bs_amp_res)
118
44051
                        sbr->data[ch].env_facs[e][k] = ff_exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
119
                    else
120
32118
                        sbr->data[ch].env_facs[e][k] = ff_exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
121
32118
                                                       * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
122
76169
                    if (sbr->data[ch].env_facs[e][k] > 1E20) {
123
                        av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
124
                        sbr->data[ch].env_facs[e][k] = 1;
125
                    }
126
                }
127
128
9437
            for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
129
24583
                for (k = 0; k < sbr->n_q; k++)
130
19087
                    sbr->data[ch].noise_facs[e][k] =
131
19087
                        ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
132
        }
133
    }
134
4450
}
135
136
/** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
137
 * (14496-3 sp04 p214)
138
 * Warning: This routine does not seem numerically stable.
139
 */
140
6631
static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
141
                                  float (*alpha0)[2], float (*alpha1)[2],
142
                                  const float X_low[32][40][2], int k0)
143
{
144
    int k;
145
130955
    for (k = 0; k < k0; k++) {
146
124324
        LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
147
        float dk;
148
149
124324
        dsp->autocorrelate(X_low[k], phi);
150
151
124324
        dk =  phi[2][1][0] * phi[1][0][0] -
152
124324
             (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
153
154
124324
        if (!dk) {
155
4007
            alpha1[k][0] = 0;
156
4007
            alpha1[k][1] = 0;
157
        } else {
158
            float temp_real, temp_im;
159
120317
            temp_real = phi[0][0][0] * phi[1][1][0] -
160
120317
                        phi[0][0][1] * phi[1][1][1] -
161
120317
                        phi[0][1][0] * phi[1][0][0];
162
120317
            temp_im   = phi[0][0][0] * phi[1][1][1] +
163
120317
                        phi[0][0][1] * phi[1][1][0] -
164
120317
                        phi[0][1][1] * phi[1][0][0];
165
166
120317
            alpha1[k][0] = temp_real / dk;
167
120317
            alpha1[k][1] = temp_im   / dk;
168
        }
169
170
124324
        if (!phi[1][0][0]) {
171
3622
            alpha0[k][0] = 0;
172
3622
            alpha0[k][1] = 0;
173
        } else {
174
            float temp_real, temp_im;
175
120702
            temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
176
120702
                                       alpha1[k][1] * phi[1][1][1];
177
120702
            temp_im   = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
178
120702
                                       alpha1[k][0] * phi[1][1][1];
179
180
120702
            alpha0[k][0] = -temp_real / phi[1][0][0];
181
120702
            alpha0[k][1] = -temp_im   / phi[1][0][0];
182
        }
183
184
124324
        if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
185
123938
           alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
186
604
            alpha1[k][0] = 0;
187
604
            alpha1[k][1] = 0;
188
604
            alpha0[k][0] = 0;
189
604
            alpha0[k][1] = 0;
190
        }
191
    }
192
6631
}
193
194
/// Chirp Factors (14496-3 sp04 p214)
195
6631
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
196
{
197
    int i;
198
    float new_bw;
199
    static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
200
201
27190
    for (i = 0; i < sbr->n_q; i++) {
202
20559
        if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
203
1293
            new_bw = 0.6f;
204
        } else
205
19266
            new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
206
207
20559
        if (new_bw < ch_data->bw_array[i]) {
208
3582
            new_bw = 0.75f    * new_bw + 0.25f    * ch_data->bw_array[i];
209
        } else
210
16977
            new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
211
20559
        ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
212
    }
213
6631
}
214
215
/**
216
 * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
217
 * and Calculation of gain (14496-3 sp04 p219)
218
 */
219
6631
static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
220
                          SBRData *ch_data, const int e_a[2])
221
{
222
    int e, k, m;
223
    // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
224
    static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
225
226
16203
    for (e = 0; e < ch_data->bs_num_env; e++) {
227

9572
        int delta = !((e == e_a[1]) || (e == e_a[0]));
228
44040
        for (k = 0; k < sbr->n_lim; k++) {
229
            float gain_boost, gain_max;
230
34468
            float sum[2] = { 0.0f, 0.0f };
231
285653
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
232
251185
                const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
233
251185
                sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
234
251185
                sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
235
251185
                if (!sbr->s_mapped[e][m]) {
236
245902
                    sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
237
245902
                                            ((1.0f + sbr->e_curr[e][m]) *
238
245902
                                             (1.0f + sbr->q_mapped[e][m] * delta)));
239
                } else {
240
5283
                    sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
241
5283
                                            ((1.0f + sbr->e_curr[e][m]) *
242
5283
                                             (1.0f + sbr->q_mapped[e][m])));
243
                }
244
251185
                sbr->gain[e][m] += FLT_MIN;
245
            }
246
285653
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
247
251185
                sum[0] += sbr->e_origmapped[e][m];
248
251185
                sum[1] += sbr->e_curr[e][m];
249
            }
250
34468
            gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
251
34468
            gain_max = FFMIN(100000.f, gain_max);
252
285653
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
253
251185
                float q_m_max   = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
254
251185
                sbr->q_m[e][m]  = FFMIN(sbr->q_m[e][m], q_m_max);
255
251185
                sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
256
            }
257
34468
            sum[0] = sum[1] = 0.0f;
258
285653
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
259
251185
                sum[0] += sbr->e_origmapped[e][m];
260
502370
                sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
261
251185
                          + sbr->s_m[e][m] * sbr->s_m[e][m]
262

251185
                          + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
263
            }
264
34468
            gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
265
34468
            gain_boost = FFMIN(1.584893192f, gain_boost);
266
285653
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
267
251185
                sbr->gain[e][m] *= gain_boost;
268
251185
                sbr->q_m[e][m]  *= gain_boost;
269
251185
                sbr->s_m[e][m]  *= gain_boost;
270
            }
271
        }
272
    }
273
6631
}
274
275
/// Assembling HF Signals (14496-3 sp04 p220)
276
6631
static void sbr_hf_assemble(float Y1[38][64][2],
277
                            const float X_high[64][40][2],
278
                            SpectralBandReplication *sbr, SBRData *ch_data,
279
                            const int e_a[2])
280
{
281
    int e, i, j, m;
282
6631
    const int h_SL = 4 * !sbr->bs_smoothing_mode;
283
6631
    const int kx = sbr->kx[1];
284
6631
    const int m_max = sbr->m[1];
285
    static const float h_smooth[5] = {
286
        0.33333333333333,
287
        0.30150283239582,
288
        0.21816949906249,
289
        0.11516383427084,
290
        0.03183050093751,
291
    };
292
6631
    float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
293
6631
    int indexnoise = ch_data->f_indexnoise;
294
6631
    int indexsine  = ch_data->f_indexsine;
295
296
6631
    if (sbr->reset) {
297
87
        for (i = 0; i < h_SL; i++) {
298
8
            memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
299
8
            memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
300
        }
301
6552
    } else if (h_SL) {
302
5730
        for (i = 0; i < 4; i++) {
303
4584
            memcpy(g_temp[i + 2 * ch_data->t_env[0]],
304
4584
                   g_temp[i + 2 * ch_data->t_env_num_env_old],
305
                   sizeof(g_temp[0]));
306
4584
            memcpy(q_temp[i + 2 * ch_data->t_env[0]],
307
4584
                   q_temp[i + 2 * ch_data->t_env_num_env_old],
308
                   sizeof(q_temp[0]));
309
        }
310
    }
311
312
16203
    for (e = 0; e < ch_data->bs_num_env; e++) {
313
221764
        for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
314
212192
            memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
315
212192
            memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
316
        }
317
    }
318
319
16203
    for (e = 0; e < ch_data->bs_num_env; e++) {
320
221764
        for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
321
212192
            LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
322
212192
            LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
323
            float *g_filt, *q_filt;
324
325

212192
            if (h_SL && e != e_a[0] && e != e_a[1]) {
326
36634
                g_filt = g_filt_tab;
327
36634
                q_filt = q_filt_tab;
328
659412
                for (m = 0; m < m_max; m++) {
329
622778
                    const int idx1 = i + h_SL;
330
622778
                    g_filt[m] = 0.0f;
331
622778
                    q_filt[m] = 0.0f;
332
3736668
                    for (j = 0; j <= h_SL; j++) {
333
3113890
                        g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
334
3113890
                        q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
335
                    }
336
                }
337
            } else {
338
175558
                g_filt = g_temp[i + h_SL];
339
175558
                q_filt = q_temp[i];
340
            }
341
342
212192
            sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
343
212192
                               i + ENVELOPE_ADJUSTMENT_OFFSET);
344
345

212192
            if (e != e_a[0] && e != e_a[1]) {
346
209970
                sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
347
                                                   q_filt, indexnoise,
348
                                                   kx, m_max);
349
            } else {
350
2222
                int idx = indexsine&1;
351
2222
                int A = (1-((indexsine+(kx & 1))&2));
352
2222
                int B = (A^(-idx)) + idx;
353
2222
                float *out = &Y1[i][kx][idx];
354
2222
                float *in  = sbr->s_m[e];
355
30250
                for (m = 0; m+1 < m_max; m+=2) {
356
28028
                    out[2*m  ] += in[m  ] * A;
357
28028
                    out[2*m+2] += in[m+1] * B;
358
                }
359
2222
                if(m_max&1)
360
1288
                    out[2*m  ] += in[m  ] * A;
361
            }
362
212192
            indexnoise = (indexnoise + m_max) & 0x1ff;
363
212192
            indexsine = (indexsine + 1) & 3;
364
        }
365
    }
366
6631
    ch_data->f_indexnoise = indexnoise;
367
6631
    ch_data->f_indexsine  = indexsine;
368
6631
}
369
370
#include "aacsbr_template.c"