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 "aacps.h" | ||
35 | #include "sbrdsp.h" | ||
36 | #include "libavutil/internal.h" | ||
37 | #include "libavutil/intfloat.h" | ||
38 | #include "libavutil/libm.h" | ||
39 | #include "libavutil/avassert.h" | ||
40 | #include "libavutil/mem_internal.h" | ||
41 | |||
42 | #include <stdint.h> | ||
43 | #include <float.h> | ||
44 | #include <math.h> | ||
45 | |||
46 | #if ARCH_MIPS | ||
47 | #include "mips/aacsbr_mips.h" | ||
48 | #endif /* ARCH_MIPS */ | ||
49 | |||
50 | /** | ||
51 | * 2^(x) for integer x | ||
52 | * @return correctly rounded float | ||
53 | */ | ||
54 | 140760 | static av_always_inline float exp2fi(int x) { | |
55 | /* Normal range */ | ||
56 |
2/4✓ Branch 0 taken 140760 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 140760 times.
✗ Branch 3 not taken.
|
140760 | if (-126 <= x && x <= 128) |
57 | 140760 | return av_int2float((x+127) << 23); | |
58 | /* Too large */ | ||
59 | ✗ | else if (x > 128) | |
60 | ✗ | return INFINITY; | |
61 | /* Subnormal numbers */ | ||
62 | ✗ | else if (x > -150) | |
63 | ✗ | return av_int2float(1 << (x+149)); | |
64 | /* Negligibly small */ | ||
65 | else | ||
66 | ✗ | return 0; | |
67 | } | ||
68 | |||
69 | static void aacsbr_func_ptr_init(AACSBRContext *c); | ||
70 | |||
71 | 116 | static void make_bands(int16_t* bands, int start, int stop, int num_bands) | |
72 | { | ||
73 | int k, previous, present; | ||
74 | float base, prod; | ||
75 | |||
76 | 116 | base = powf((float)stop / start, 1.0f / num_bands); | |
77 | 116 | prod = start; | |
78 | 116 | previous = start; | |
79 | |||
80 |
2/2✓ Branch 0 taken 1194 times.
✓ Branch 1 taken 116 times.
|
1310 | for (k = 0; k < num_bands-1; k++) { |
81 | 1194 | prod *= base; | |
82 | 1194 | present = lrintf(prod); | |
83 | 1194 | bands[k] = present - previous; | |
84 | 1194 | previous = present; | |
85 | } | ||
86 | 116 | bands[num_bands-1] = stop - previous; | |
87 | 116 | } | |
88 | |||
89 | /// Dequantization and stereo decoding (14496-3 sp04 p203) | ||
90 | 4450 | static void sbr_dequant(SpectralBandReplication *sbr, int id_aac) | |
91 | { | ||
92 | int k, e; | ||
93 | int ch; | ||
94 | static const double exp2_tab[2] = {1, M_SQRT2}; | ||
95 |
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) { |
96 |
2/2✓ Branch 0 taken 305 times.
✓ Branch 1 taken 1040 times.
|
1345 | int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24; |
97 |
2/2✓ Branch 0 taken 1758 times.
✓ Branch 1 taken 1345 times.
|
3103 | for (e = 1; e <= sbr->data[0].bs_num_env; e++) { |
98 |
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++) { |
99 | float temp1, temp2, fac; | ||
100 |
2/2✓ Branch 0 taken 7387 times.
✓ Branch 1 taken 10998 times.
|
18385 | if (sbr->data[0].bs_amp_res) { |
101 | 7387 | temp1 = exp2fi(sbr->data[0].env_facs_q[e][k] + 7); | |
102 | 7387 | temp2 = exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]); | |
103 | } | ||
104 | else { | ||
105 | 10998 | temp1 = exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) * | |
106 | 10998 | exp2_tab[sbr->data[0].env_facs_q[e][k] & 1]; | |
107 | 10998 | temp2 = exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) * | |
108 | 10998 | exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1]; | |
109 | } | ||
110 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18385 times.
|
18385 | if (temp1 > 1E20) { |
111 | ✗ | av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n"); | |
112 | ✗ | temp1 = 1; | |
113 | } | ||
114 | 18385 | fac = temp1 / (1.0f + temp2); | |
115 | 18385 | sbr->data[0].env_facs[e][k] = fac; | |
116 | 18385 | sbr->data[1].env_facs[e][k] = fac * temp2; | |
117 | } | ||
118 | } | ||
119 |
2/2✓ Branch 0 taken 1650 times.
✓ Branch 1 taken 1345 times.
|
2995 | for (e = 1; e <= sbr->data[0].bs_num_noise; e++) { |
120 |
2/2✓ Branch 0 taken 4367 times.
✓ Branch 1 taken 1650 times.
|
6017 | for (k = 0; k < sbr->n_q; k++) { |
121 | 4367 | float temp1 = exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1); | |
122 | 4367 | float temp2 = exp2fi(12 - sbr->data[1].noise_facs_q[e][k]); | |
123 | float fac; | ||
124 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4367 times.
|
4367 | av_assert0(temp1 <= 1E20); |
125 | 4367 | fac = temp1 / (1.0f + temp2); | |
126 | 4367 | sbr->data[0].noise_facs[e][k] = fac; | |
127 | 4367 | sbr->data[1].noise_facs[e][k] = fac * temp2; | |
128 | } | ||
129 | } | ||
130 | } else { // SCE or one non-coupled CPE | ||
131 |
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++) { |
132 |
2/2✓ Branch 0 taken 6056 times.
✓ Branch 1 taken 3941 times.
|
9997 | for (e = 1; e <= sbr->data[ch].bs_num_env; e++) |
133 |
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++){ |
134 |
2/2✓ Branch 0 taken 44051 times.
✓ Branch 1 taken 32118 times.
|
76169 | if (sbr->data[ch].bs_amp_res) |
135 | 44051 | sbr->data[ch].env_facs[e][k] = exp2fi(sbr->data[ch].env_facs_q[e][k] + 6); | |
136 | else | ||
137 | 32118 | sbr->data[ch].env_facs[e][k] = exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6) | |
138 | 32118 | * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1]; | |
139 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76169 times.
|
76169 | if (sbr->data[ch].env_facs[e][k] > 1E20) { |
140 | ✗ | av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n"); | |
141 | ✗ | sbr->data[ch].env_facs[e][k] = 1; | |
142 | } | ||
143 | } | ||
144 | |||
145 |
2/2✓ Branch 0 taken 5496 times.
✓ Branch 1 taken 3941 times.
|
9437 | for (e = 1; e <= sbr->data[ch].bs_num_noise; e++) |
146 |
2/2✓ Branch 0 taken 19087 times.
✓ Branch 1 taken 5496 times.
|
24583 | for (k = 0; k < sbr->n_q; k++) |
147 | 19087 | sbr->data[ch].noise_facs[e][k] = | |
148 | 19087 | exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]); | |
149 | } | ||
150 | } | ||
151 | 4450 | } | |
152 | |||
153 | /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering | ||
154 | * (14496-3 sp04 p214) | ||
155 | * Warning: This routine does not seem numerically stable. | ||
156 | */ | ||
157 | 6631 | static void sbr_hf_inverse_filter(SBRDSPContext *dsp, | |
158 | float (*alpha0)[2], float (*alpha1)[2], | ||
159 | const float X_low[32][40][2], int k0) | ||
160 | { | ||
161 | int k; | ||
162 |
2/2✓ Branch 0 taken 124324 times.
✓ Branch 1 taken 6631 times.
|
130955 | for (k = 0; k < k0; k++) { |
163 | 124324 | LOCAL_ALIGNED_16(float, phi, [3], [2][2]); | |
164 | float dk; | ||
165 | |||
166 | 124324 | dsp->autocorrelate(X_low[k], phi); | |
167 | |||
168 | 124324 | dk = phi[2][1][0] * phi[1][0][0] - | |
169 | 124324 | (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f; | |
170 | |||
171 |
2/2✓ Branch 0 taken 4007 times.
✓ Branch 1 taken 120317 times.
|
124324 | if (!dk) { |
172 | 4007 | alpha1[k][0] = 0; | |
173 | 4007 | alpha1[k][1] = 0; | |
174 | } else { | ||
175 | float temp_real, temp_im; | ||
176 | 120317 | temp_real = phi[0][0][0] * phi[1][1][0] - | |
177 | 120317 | phi[0][0][1] * phi[1][1][1] - | |
178 | 120317 | phi[0][1][0] * phi[1][0][0]; | |
179 | 120317 | temp_im = phi[0][0][0] * phi[1][1][1] + | |
180 | 120317 | phi[0][0][1] * phi[1][1][0] - | |
181 | 120317 | phi[0][1][1] * phi[1][0][0]; | |
182 | |||
183 | 120317 | alpha1[k][0] = temp_real / dk; | |
184 | 120317 | alpha1[k][1] = temp_im / dk; | |
185 | } | ||
186 | |||
187 |
2/2✓ Branch 0 taken 3622 times.
✓ Branch 1 taken 120702 times.
|
124324 | if (!phi[1][0][0]) { |
188 | 3622 | alpha0[k][0] = 0; | |
189 | 3622 | alpha0[k][1] = 0; | |
190 | } else { | ||
191 | float temp_real, temp_im; | ||
192 | 120702 | temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] + | |
193 | 120702 | alpha1[k][1] * phi[1][1][1]; | |
194 | 120702 | temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] - | |
195 | 120702 | alpha1[k][0] * phi[1][1][1]; | |
196 | |||
197 | 120702 | alpha0[k][0] = -temp_real / phi[1][0][0]; | |
198 | 120702 | alpha0[k][1] = -temp_im / phi[1][0][0]; | |
199 | } | ||
200 | |||
201 |
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 || |
202 |
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) { |
203 | 604 | alpha1[k][0] = 0; | |
204 | 604 | alpha1[k][1] = 0; | |
205 | 604 | alpha0[k][0] = 0; | |
206 | 604 | alpha0[k][1] = 0; | |
207 | } | ||
208 | } | ||
209 | 6631 | } | |
210 | |||
211 | /// Chirp Factors (14496-3 sp04 p214) | ||
212 | 6631 | static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data) | |
213 | { | ||
214 | int i; | ||
215 | float new_bw; | ||
216 | static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f }; | ||
217 | |||
218 |
2/2✓ Branch 0 taken 20559 times.
✓ Branch 1 taken 6631 times.
|
27190 | for (i = 0; i < sbr->n_q; i++) { |
219 |
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) { |
220 | 1293 | new_bw = 0.6f; | |
221 | } else | ||
222 | 19266 | new_bw = bw_tab[ch_data->bs_invf_mode[0][i]]; | |
223 | |||
224 |
2/2✓ Branch 0 taken 3582 times.
✓ Branch 1 taken 16977 times.
|
20559 | if (new_bw < ch_data->bw_array[i]) { |
225 | 3582 | new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i]; | |
226 | } else | ||
227 | 16977 | new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i]; | |
228 |
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; |
229 | } | ||
230 | 6631 | } | |
231 | |||
232 | /** | ||
233 | * Calculation of levels of additional HF signal components (14496-3 sp04 p219) | ||
234 | * and Calculation of gain (14496-3 sp04 p219) | ||
235 | */ | ||
236 | 6631 | static void sbr_gain_calc(SpectralBandReplication *sbr, | |
237 | SBRData *ch_data, const int e_a[2]) | ||
238 | { | ||
239 | int e, k, m; | ||
240 | // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off) | ||
241 | static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 }; | ||
242 | |||
243 |
2/2✓ Branch 0 taken 9572 times.
✓ Branch 1 taken 6631 times.
|
16203 | for (e = 0; e < ch_data->bs_num_env; e++) { |
244 |
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])); |
245 |
2/2✓ Branch 0 taken 34468 times.
✓ Branch 1 taken 9572 times.
|
44040 | for (k = 0; k < sbr->n_lim; k++) { |
246 | float gain_boost, gain_max; | ||
247 | 34468 | float sum[2] = { 0.0f, 0.0f }; | |
248 |
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++) { |
249 | 251185 | const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]); | |
250 | 251185 | sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]); | |
251 | 251185 | sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]); | |
252 |
2/2✓ Branch 0 taken 245902 times.
✓ Branch 1 taken 5283 times.
|
251185 | if (!sbr->s_mapped[e][m]) { |
253 | 245902 | sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] / | |
254 | 245902 | ((1.0f + sbr->e_curr[e][m]) * | |
255 | 245902 | (1.0f + sbr->q_mapped[e][m] * delta))); | |
256 | } else { | ||
257 | 5283 | sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] / | |
258 | 5283 | ((1.0f + sbr->e_curr[e][m]) * | |
259 | 5283 | (1.0f + sbr->q_mapped[e][m]))); | |
260 | } | ||
261 | 251185 | sbr->gain[e][m] += FLT_MIN; | |
262 | } | ||
263 |
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++) { |
264 | 251185 | sum[0] += sbr->e_origmapped[e][m]; | |
265 | 251185 | sum[1] += sbr->e_curr[e][m]; | |
266 | } | ||
267 | 34468 | gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1])); | |
268 |
2/2✓ Branch 0 taken 30554 times.
✓ Branch 1 taken 3914 times.
|
34468 | gain_max = FFMIN(100000.f, gain_max); |
269 |
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++) { |
270 | 251185 | float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m]; | |
271 |
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); |
272 |
2/2✓ Branch 0 taken 60467 times.
✓ Branch 1 taken 190718 times.
|
251185 | sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max); |
273 | } | ||
274 | 34468 | sum[0] = sum[1] = 0.0f; | |
275 |
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++) { |
276 | 251185 | sum[0] += sbr->e_origmapped[e][m]; | |
277 | 502370 | sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m] | |
278 | 251185 | + sbr->s_m[e][m] * sbr->s_m[e][m] | |
279 |
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]; |
280 | } | ||
281 | 34468 | gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1])); | |
282 |
2/2✓ Branch 0 taken 29421 times.
✓ Branch 1 taken 5047 times.
|
34468 | gain_boost = FFMIN(1.584893192f, gain_boost); |
283 |
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++) { |
284 | 251185 | sbr->gain[e][m] *= gain_boost; | |
285 | 251185 | sbr->q_m[e][m] *= gain_boost; | |
286 | 251185 | sbr->s_m[e][m] *= gain_boost; | |
287 | } | ||
288 | } | ||
289 | } | ||
290 | 6631 | } | |
291 | |||
292 | /// Assembling HF Signals (14496-3 sp04 p220) | ||
293 | 6631 | static void sbr_hf_assemble(float Y1[38][64][2], | |
294 | const float X_high[64][40][2], | ||
295 | SpectralBandReplication *sbr, SBRData *ch_data, | ||
296 | const int e_a[2]) | ||
297 | { | ||
298 | int e, i, j, m; | ||
299 |
2/2✓ Branch 0 taken 1148 times.
✓ Branch 1 taken 5483 times.
|
6631 | const int h_SL = 4 * !sbr->bs_smoothing_mode; |
300 | 6631 | const int kx = sbr->kx[1]; | |
301 | 6631 | const int m_max = sbr->m[1]; | |
302 | static const float h_smooth[5] = { | ||
303 | 0.33333333333333, | ||
304 | 0.30150283239582, | ||
305 | 0.21816949906249, | ||
306 | 0.11516383427084, | ||
307 | 0.03183050093751, | ||
308 | }; | ||
309 | 6631 | float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp; | |
310 | 6631 | int indexnoise = ch_data->f_indexnoise; | |
311 | 6631 | int indexsine = ch_data->f_indexsine; | |
312 | |||
313 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 6552 times.
|
6631 | if (sbr->reset) { |
314 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 79 times.
|
87 | for (i = 0; i < h_SL; i++) { |
315 | 8 | memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0])); | |
316 | 8 | memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0])); | |
317 | } | ||
318 |
2/2✓ Branch 0 taken 1146 times.
✓ Branch 1 taken 5406 times.
|
6552 | } else if (h_SL) { |
319 |
2/2✓ Branch 0 taken 4584 times.
✓ Branch 1 taken 1146 times.
|
5730 | for (i = 0; i < 4; i++) { |
320 | 4584 | memcpy(g_temp[i + 2 * ch_data->t_env[0]], | |
321 | 4584 | g_temp[i + 2 * ch_data->t_env_num_env_old], | |
322 | sizeof(g_temp[0])); | ||
323 | 4584 | memcpy(q_temp[i + 2 * ch_data->t_env[0]], | |
324 | 4584 | q_temp[i + 2 * ch_data->t_env_num_env_old], | |
325 | sizeof(q_temp[0])); | ||
326 | } | ||
327 | } | ||
328 | |||
329 |
2/2✓ Branch 0 taken 9572 times.
✓ Branch 1 taken 6631 times.
|
16203 | for (e = 0; e < ch_data->bs_num_env; e++) { |
330 |
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++) { |
331 | 212192 | memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0])); | |
332 | 212192 | memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0])); | |
333 | } | ||
334 | } | ||
335 | |||
336 |
2/2✓ Branch 0 taken 9572 times.
✓ Branch 1 taken 6631 times.
|
16203 | for (e = 0; e < ch_data->bs_num_env; e++) { |
337 |
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++) { |
338 | 212192 | LOCAL_ALIGNED_16(float, g_filt_tab, [48]); | |
339 | 212192 | LOCAL_ALIGNED_16(float, q_filt_tab, [48]); | |
340 | float *g_filt, *q_filt; | ||
341 | |||
342 |
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]) { |
343 | 36634 | g_filt = g_filt_tab; | |
344 | 36634 | q_filt = q_filt_tab; | |
345 |
2/2✓ Branch 0 taken 622778 times.
✓ Branch 1 taken 36634 times.
|
659412 | for (m = 0; m < m_max; m++) { |
346 | 622778 | const int idx1 = i + h_SL; | |
347 | 622778 | g_filt[m] = 0.0f; | |
348 | 622778 | q_filt[m] = 0.0f; | |
349 |
2/2✓ Branch 0 taken 3113890 times.
✓ Branch 1 taken 622778 times.
|
3736668 | for (j = 0; j <= h_SL; j++) { |
350 | 3113890 | g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j]; | |
351 | 3113890 | q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j]; | |
352 | } | ||
353 | } | ||
354 | } else { | ||
355 | 175558 | g_filt = g_temp[i + h_SL]; | |
356 | 175558 | q_filt = q_temp[i]; | |
357 | } | ||
358 | |||
359 | 212192 | sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max, | |
360 | 212192 | i + ENVELOPE_ADJUSTMENT_OFFSET); | |
361 | |||
362 |
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]) { |
363 | 209970 | sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e], | |
364 | q_filt, indexnoise, | ||
365 | kx, m_max); | ||
366 | } else { | ||
367 | 2222 | int idx = indexsine&1; | |
368 | 2222 | int A = (1-((indexsine+(kx & 1))&2)); | |
369 | 2222 | int B = (A^(-idx)) + idx; | |
370 | 2222 | float *out = &Y1[i][kx][idx]; | |
371 | 2222 | float *in = sbr->s_m[e]; | |
372 |
2/2✓ Branch 0 taken 28028 times.
✓ Branch 1 taken 2222 times.
|
30250 | for (m = 0; m+1 < m_max; m+=2) { |
373 | 28028 | out[2*m ] += in[m ] * A; | |
374 | 28028 | out[2*m+2] += in[m+1] * B; | |
375 | } | ||
376 |
2/2✓ Branch 0 taken 1288 times.
✓ Branch 1 taken 934 times.
|
2222 | if(m_max&1) |
377 | 1288 | out[2*m ] += in[m ] * A; | |
378 | } | ||
379 | 212192 | indexnoise = (indexnoise + m_max) & 0x1ff; | |
380 | 212192 | indexsine = (indexsine + 1) & 3; | |
381 | } | ||
382 | } | ||
383 | 6631 | ch_data->f_indexnoise = indexnoise; | |
384 | 6631 | ch_data->f_indexsine = indexsine; | |
385 | 6631 | } | |
386 | |||
387 | #include "aacsbr_template.c" | ||
388 |