Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/aacsbr.c |
Date: | 2022-07-04 19:11:22 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 186 | 190 | 97.9% |
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 "fft.h" | ||
35 | #include "internal.h" | ||
36 | #include "aacps.h" | ||
37 | #include "sbrdsp.h" | ||
38 | #include "libavutil/internal.h" | ||
39 | #include "libavutil/libm.h" | ||
40 | #include "libavutil/avassert.h" | ||
41 | #include "libavutil/mem_internal.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 |
2/2✓ Branch 0 taken 1194 times.
✓ Branch 1 taken 116 times.
|
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 |
4/4✓ Branch 0 taken 2181 times.
✓ Branch 1 taken 2269 times.
✓ Branch 2 taken 1345 times.
✓ Branch 3 taken 836 times.
|
5795 | if (id_aac == TYPE_CPE && sbr->bs_coupling) { |
79 |
2/2✓ Branch 0 taken 305 times.
✓ Branch 1 taken 1040 times.
|
1345 | int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24; |
80 |
2/2✓ Branch 0 taken 1758 times.
✓ Branch 1 taken 1345 times.
|
3103 | for (e = 1; e <= sbr->data[0].bs_num_env; e++) { |
81 |
2/2✓ Branch 0 taken 18385 times.
✓ Branch 1 taken 1758 times.
|
20143 | for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) { |
82 | float temp1, temp2, fac; | ||
83 |
2/2✓ Branch 0 taken 7387 times.
✓ Branch 1 taken 10998 times.
|
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 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18385 times.
|
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 |
2/2✓ Branch 0 taken 1650 times.
✓ Branch 1 taken 1345 times.
|
2995 | for (e = 1; e <= sbr->data[0].bs_num_noise; e++) { |
103 |
2/2✓ Branch 0 taken 4367 times.
✓ Branch 1 taken 1650 times.
|
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 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4367 times.
|
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 |
4/4✓ Branch 0 taken 2508 times.
✓ Branch 1 taken 4538 times.
✓ Branch 2 taken 3941 times.
✓ Branch 3 taken 3105 times.
|
7046 | for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) { |
115 |
2/2✓ Branch 0 taken 6056 times.
✓ Branch 1 taken 3941 times.
|
9997 | for (e = 1; e <= sbr->data[ch].bs_num_env; e++) |
116 |
2/2✓ Branch 0 taken 76169 times.
✓ Branch 1 taken 6056 times.
|
82225 | for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){ |
117 |
2/2✓ Branch 0 taken 44051 times.
✓ Branch 1 taken 32118 times.
|
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 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76169 times.
|
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 |
2/2✓ Branch 0 taken 5496 times.
✓ Branch 1 taken 3941 times.
|
9437 | for (e = 1; e <= sbr->data[ch].bs_num_noise; e++) |
129 |
2/2✓ Branch 0 taken 19087 times.
✓ Branch 1 taken 5496 times.
|
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 |
2/2✓ Branch 0 taken 124324 times.
✓ Branch 1 taken 6631 times.
|
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 |
2/2✓ Branch 0 taken 4007 times.
✓ Branch 1 taken 120317 times.
|
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 |
2/2✓ Branch 0 taken 3622 times.
✓ Branch 1 taken 120702 times.
|
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 |
2/2✓ Branch 0 taken 123938 times.
✓ Branch 1 taken 386 times.
|
124324 | if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f || |
185 |
2/2✓ Branch 0 taken 218 times.
✓ Branch 1 taken 123720 times.
|
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 |
2/2✓ Branch 0 taken 20559 times.
✓ Branch 1 taken 6631 times.
|
27190 | for (i = 0; i < sbr->n_q; i++) { |
202 |
2/2✓ Branch 0 taken 1293 times.
✓ Branch 1 taken 19266 times.
|
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 |
2/2✓ Branch 0 taken 3582 times.
✓ Branch 1 taken 16977 times.
|
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 |
2/2✓ Branch 0 taken 3343 times.
✓ Branch 1 taken 17216 times.
|
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 |
2/2✓ Branch 0 taken 9572 times.
✓ Branch 1 taken 6631 times.
|
16203 | for (e = 0; e < ch_data->bs_num_env; e++) { |
227 |
4/4✓ Branch 0 taken 9173 times.
✓ Branch 1 taken 399 times.
✓ Branch 2 taken 9032 times.
✓ Branch 3 taken 141 times.
|
9572 | int delta = !((e == e_a[1]) || (e == e_a[0])); |
228 |
2/2✓ Branch 0 taken 34468 times.
✓ Branch 1 taken 9572 times.
|
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 |
2/2✓ Branch 0 taken 251185 times.
✓ Branch 1 taken 34468 times.
|
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 |
2/2✓ Branch 0 taken 245902 times.
✓ Branch 1 taken 5283 times.
|
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 |
2/2✓ Branch 0 taken 251185 times.
✓ Branch 1 taken 34468 times.
|
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 |
2/2✓ Branch 0 taken 30554 times.
✓ Branch 1 taken 3914 times.
|
34468 | gain_max = FFMIN(100000.f, gain_max); |
252 |
2/2✓ Branch 0 taken 251185 times.
✓ Branch 1 taken 34468 times.
|
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 |
2/2✓ Branch 0 taken 60467 times.
✓ Branch 1 taken 190718 times.
|
251185 | sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max); |
255 |
2/2✓ Branch 0 taken 60467 times.
✓ Branch 1 taken 190718 times.
|
251185 | sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max); |
256 | } | ||
257 | 34468 | sum[0] = sum[1] = 0.0f; | |
258 |
2/2✓ Branch 0 taken 251185 times.
✓ Branch 1 taken 34468 times.
|
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 |
4/4✓ Branch 0 taken 237234 times.
✓ Branch 1 taken 13951 times.
✓ Branch 2 taken 235344 times.
✓ Branch 3 taken 1890 times.
|
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 |
2/2✓ Branch 0 taken 29421 times.
✓ Branch 1 taken 5047 times.
|
34468 | gain_boost = FFMIN(1.584893192f, gain_boost); |
266 |
2/2✓ Branch 0 taken 251185 times.
✓ Branch 1 taken 34468 times.
|
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 |
2/2✓ Branch 0 taken 1148 times.
✓ Branch 1 taken 5483 times.
|
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 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 6552 times.
|
6631 | if (sbr->reset) { |
297 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 79 times.
|
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 |
2/2✓ Branch 0 taken 1146 times.
✓ Branch 1 taken 5406 times.
|
6552 | } else if (h_SL) { |
302 |
2/2✓ Branch 0 taken 4584 times.
✓ Branch 1 taken 1146 times.
|
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 |
2/2✓ Branch 0 taken 9572 times.
✓ Branch 1 taken 6631 times.
|
16203 | for (e = 0; e < ch_data->bs_num_env; e++) { |
313 |
2/2✓ Branch 0 taken 212192 times.
✓ Branch 1 taken 9572 times.
|
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 |
2/2✓ Branch 0 taken 9572 times.
✓ Branch 1 taken 6631 times.
|
16203 | for (e = 0; e < ch_data->bs_num_env; e++) { |
320 |
2/2✓ Branch 0 taken 212192 times.
✓ Branch 1 taken 9572 times.
|
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 |
6/6✓ Branch 0 taken 36736 times.
✓ Branch 1 taken 175456 times.
✓ Branch 2 taken 36694 times.
✓ Branch 3 taken 42 times.
✓ Branch 4 taken 36634 times.
✓ Branch 5 taken 60 times.
|
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 |
2/2✓ Branch 0 taken 622778 times.
✓ Branch 1 taken 36634 times.
|
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 |
2/2✓ Branch 0 taken 3113890 times.
✓ Branch 1 taken 622778 times.
|
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 |
4/4✓ Branch 0 taken 211598 times.
✓ Branch 1 taken 594 times.
✓ Branch 2 taken 209970 times.
✓ Branch 3 taken 1628 times.
|
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 |
2/2✓ Branch 0 taken 28028 times.
✓ Branch 1 taken 2222 times.
|
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 |
2/2✓ Branch 0 taken 1288 times.
✓ Branch 1 taken 934 times.
|
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" | ||
371 |