Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/aacsbr_fixed.c |
Date: | 2022-07-05 19:52:29 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 272 | 292 | 93.2% |
Branches: | 163 | 174 | 93.7% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Copyright (c) 2013 | ||
3 | * MIPS Technologies, Inc., California. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its | ||
14 | * contributors may be used to endorse or promote products derived from | ||
15 | * this software without specific prior written permission. | ||
16 | * | ||
17 | * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND | ||
18 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
19 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
20 | * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE | ||
21 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
22 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
23 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
24 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
25 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
26 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
27 | * SUCH DAMAGE. | ||
28 | * | ||
29 | * AAC Spectral Band Replication decoding functions (fixed-point) | ||
30 | * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl ) | ||
31 | * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com> | ||
32 | * | ||
33 | * This file is part of FFmpeg. | ||
34 | * | ||
35 | * FFmpeg is free software; you can redistribute it and/or | ||
36 | * modify it under the terms of the GNU Lesser General Public | ||
37 | * License as published by the Free Software Foundation; either | ||
38 | * version 2.1 of the License, or (at your option) any later version. | ||
39 | * | ||
40 | * FFmpeg is distributed in the hope that it will be useful, | ||
41 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
42 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
43 | * Lesser General Public License for more details. | ||
44 | * | ||
45 | * You should have received a copy of the GNU Lesser General Public | ||
46 | * License along with FFmpeg; if not, write to the Free Software | ||
47 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
48 | */ | ||
49 | |||
50 | /** | ||
51 | * @file | ||
52 | * AAC Spectral Band Replication decoding functions (fixed-point) | ||
53 | * Note: Rounding-to-nearest used unless otherwise stated | ||
54 | * @author Robert Swain ( rob opendot cl ) | ||
55 | * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com ) | ||
56 | */ | ||
57 | #define USE_FIXED 1 | ||
58 | |||
59 | #include "aac.h" | ||
60 | #include "sbr.h" | ||
61 | #include "aacsbr.h" | ||
62 | #include "aacsbrdata.h" | ||
63 | #include "fft.h" | ||
64 | #include "aacps.h" | ||
65 | #include "sbrdsp.h" | ||
66 | #include "libavutil/internal.h" | ||
67 | #include "libavutil/libm.h" | ||
68 | #include "libavutil/avassert.h" | ||
69 | |||
70 | #include <stdint.h> | ||
71 | #include <float.h> | ||
72 | #include <math.h> | ||
73 | |||
74 | static VLC vlc_sbr[10]; | ||
75 | static void aacsbr_func_ptr_init(AACSBRContext *c); | ||
76 | static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256 | ||
77 | static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2) | ||
78 | static const int CONST_076923 = Q31(0.76923076923076923077f); | ||
79 | |||
80 | static const int fixed_log_table[10] = | ||
81 | { | ||
82 | Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6), | ||
83 | Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11) | ||
84 | }; | ||
85 | |||
86 | 24 | static int fixed_log(int x) | |
87 | { | ||
88 | int i, ret, xpow, tmp; | ||
89 | |||
90 | 24 | ret = x; | |
91 | 24 | xpow = x; | |
92 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 24 times.
|
144 | for (i=0; i<10; i+=2){ |
93 | 120 | xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31); | |
94 | 120 | tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31); | |
95 | 120 | ret -= tmp; | |
96 | |||
97 | 120 | xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31); | |
98 | 120 | tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31); | |
99 | 120 | ret += tmp; | |
100 | } | ||
101 | |||
102 | 24 | return ret; | |
103 | } | ||
104 | |||
105 | static const int fixed_exp_table[7] = | ||
106 | { | ||
107 | Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120), | ||
108 | Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320) | ||
109 | }; | ||
110 | |||
111 | 12 | static int fixed_exp(int x) | |
112 | { | ||
113 | int i, ret, xpow, tmp; | ||
114 | |||
115 | 12 | ret = 0x800000 + x; | |
116 | 12 | xpow = x; | |
117 |
2/2✓ Branch 0 taken 84 times.
✓ Branch 1 taken 12 times.
|
96 | for (i=0; i<7; i++){ |
118 | 84 | xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23); | |
119 | 84 | tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31); | |
120 | 84 | ret += tmp; | |
121 | } | ||
122 | |||
123 | 12 | return ret; | |
124 | } | ||
125 | |||
126 | 12 | static void make_bands(int16_t* bands, int start, int stop, int num_bands) | |
127 | { | ||
128 | int k, previous, present; | ||
129 | 12 | int base, prod, nz = 0; | |
130 | |||
131 | 12 | base = (stop << 23) / start; | |
132 |
2/2✓ Branch 0 taken 73 times.
✓ Branch 1 taken 12 times.
|
85 | while (base < 0x40000000){ |
133 | 73 | base <<= 1; | |
134 | 73 | nz++; | |
135 | } | ||
136 | 12 | base = fixed_log(base - 0x80000000); | |
137 | 12 | base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands; | |
138 | 12 | base = fixed_exp(base); | |
139 | |||
140 | 12 | previous = start; | |
141 | 12 | prod = start << 23; | |
142 | |||
143 |
2/2✓ Branch 0 taken 111 times.
✓ Branch 1 taken 12 times.
|
123 | for (k = 0; k < num_bands-1; k++) { |
144 | 111 | prod = (int)(((int64_t)prod * base + 0x400000) >> 23); | |
145 | 111 | present = (prod + 0x400000) >> 23; | |
146 | 111 | bands[k] = present - previous; | |
147 | 111 | previous = present; | |
148 | } | ||
149 | 12 | bands[num_bands-1] = stop - previous; | |
150 | 12 | } | |
151 | |||
152 | /// Dequantization and stereo decoding (14496-3 sp04 p203) | ||
153 | 2082 | static void sbr_dequant(SpectralBandReplication *sbr, int id_aac) | |
154 | { | ||
155 | int k, e; | ||
156 | int ch; | ||
157 | |||
158 |
4/4✓ Branch 0 taken 1705 times.
✓ Branch 1 taken 377 times.
✓ Branch 2 taken 1280 times.
✓ Branch 3 taken 425 times.
|
3362 | if (id_aac == TYPE_CPE && sbr->bs_coupling) { |
159 |
2/2✓ Branch 0 taken 277 times.
✓ Branch 1 taken 1003 times.
|
1280 | int alpha = sbr->data[0].bs_amp_res ? 2 : 1; |
160 |
2/2✓ Branch 0 taken 277 times.
✓ Branch 1 taken 1003 times.
|
1280 | int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24; |
161 |
2/2✓ Branch 0 taken 1642 times.
✓ Branch 1 taken 1280 times.
|
2922 | for (e = 1; e <= sbr->data[0].bs_num_env; e++) { |
162 |
2/2✓ Branch 0 taken 17423 times.
✓ Branch 1 taken 1642 times.
|
19065 | for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) { |
163 | SoftFloat temp1, temp2, fac; | ||
164 | |||
165 | 17423 | temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14; | |
166 |
2/2✓ Branch 0 taken 4733 times.
✓ Branch 1 taken 12690 times.
|
17423 | if (temp1.exp & 1) |
167 | 4733 | temp1.mant = 759250125; | |
168 | else | ||
169 | 12690 | temp1.mant = 0x20000000; | |
170 | 17423 | temp1.exp = (temp1.exp >> 1) + 1; | |
171 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17423 times.
|
17423 | if (temp1.exp > 66) { // temp1 > 1E20 |
172 | ✗ | av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n"); | |
173 | ✗ | temp1 = FLOAT_1; | |
174 | } | ||
175 | |||
176 | 17423 | temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha; | |
177 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17423 times.
|
17423 | if (temp2.exp & 1) |
178 | ✗ | temp2.mant = 759250125; | |
179 | else | ||
180 | 17423 | temp2.mant = 0x20000000; | |
181 | 17423 | temp2.exp = (temp2.exp >> 1) + 1; | |
182 | 17423 | fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2)); | |
183 | 17423 | sbr->data[0].env_facs[e][k] = fac; | |
184 | 17423 | sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2); | |
185 | } | ||
186 | } | ||
187 |
2/2✓ Branch 0 taken 1557 times.
✓ Branch 1 taken 1280 times.
|
2837 | for (e = 1; e <= sbr->data[0].bs_num_noise; e++) { |
188 |
2/2✓ Branch 0 taken 4142 times.
✓ Branch 1 taken 1557 times.
|
5699 | for (k = 0; k < sbr->n_q; k++) { |
189 | SoftFloat temp1, temp2, fac; | ||
190 | |||
191 | 4142 | temp1.exp = NOISE_FLOOR_OFFSET - \ | |
192 | 4142 | sbr->data[0].noise_facs_q[e][k] + 2; | |
193 | 4142 | temp1.mant = 0x20000000; | |
194 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4142 times.
|
4142 | av_assert0(temp1.exp <= 66); |
195 | 4142 | temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1; | |
196 | 4142 | temp2.mant = 0x20000000; | |
197 | 4142 | fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2)); | |
198 | 4142 | sbr->data[0].noise_facs[e][k] = fac; | |
199 | 4142 | sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2); | |
200 | } | ||
201 | } | ||
202 | } else { // SCE or one non-coupled CPE | ||
203 |
4/4✓ Branch 0 taken 1275 times.
✓ Branch 1 taken 754 times.
✓ Branch 2 taken 1227 times.
✓ Branch 3 taken 802 times.
|
2029 | for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) { |
204 |
2/2✓ Branch 0 taken 727 times.
✓ Branch 1 taken 500 times.
|
1227 | int alpha = sbr->data[ch].bs_amp_res ? 2 : 1; |
205 |
2/2✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 1227 times.
|
3531 | for (e = 1; e <= sbr->data[ch].bs_num_env; e++) |
206 |
2/2✓ Branch 0 taken 24131 times.
✓ Branch 1 taken 2304 times.
|
26435 | for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){ |
207 | SoftFloat temp1; | ||
208 | |||
209 | 24131 | temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12; | |
210 |
2/2✓ Branch 0 taken 2958 times.
✓ Branch 1 taken 21173 times.
|
24131 | if (temp1.exp & 1) |
211 | 2958 | temp1.mant = 759250125; | |
212 | else | ||
213 | 21173 | temp1.mant = 0x20000000; | |
214 | 24131 | temp1.exp = (temp1.exp >> 1) + 1; | |
215 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24131 times.
|
24131 | if (temp1.exp > 66) { // temp1 > 1E20 |
216 | ✗ | av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n"); | |
217 | ✗ | temp1 = FLOAT_1; | |
218 | } | ||
219 | 24131 | sbr->data[ch].env_facs[e][k] = temp1; | |
220 | } | ||
221 |
2/2✓ Branch 0 taken 1954 times.
✓ Branch 1 taken 1227 times.
|
3181 | for (e = 1; e <= sbr->data[ch].bs_num_noise; e++) |
222 |
2/2✓ Branch 0 taken 5702 times.
✓ Branch 1 taken 1954 times.
|
7656 | for (k = 0; k < sbr->n_q; k++){ |
223 | 5702 | sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \ | |
224 | 5702 | sbr->data[ch].noise_facs_q[e][k] + 1; | |
225 | 5702 | sbr->data[ch].noise_facs[e][k].mant = 0x20000000; | |
226 | } | ||
227 | } | ||
228 | } | ||
229 | 2082 | } | |
230 | |||
231 | /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering | ||
232 | * (14496-3 sp04 p214) | ||
233 | * Warning: This routine does not seem numerically stable. | ||
234 | */ | ||
235 | 3787 | static void sbr_hf_inverse_filter(SBRDSPContext *dsp, | |
236 | int (*alpha0)[2], int (*alpha1)[2], | ||
237 | const int X_low[32][40][2], int k0) | ||
238 | { | ||
239 | int k; | ||
240 | int shift, round; | ||
241 | |||
242 |
2/2✓ Branch 0 taken 68098 times.
✓ Branch 1 taken 3787 times.
|
71885 | for (k = 0; k < k0; k++) { |
243 | SoftFloat phi[3][2][2]; | ||
244 | SoftFloat a00, a01, a10, a11; | ||
245 | SoftFloat dk; | ||
246 | |||
247 | 68098 | dsp->autocorrelate(X_low[k], phi); | |
248 | |||
249 | 68098 | dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]), | |
250 | av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]), | ||
251 | av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999)); | ||
252 | |||
253 |
2/2✓ Branch 0 taken 1708 times.
✓ Branch 1 taken 66390 times.
|
68098 | if (!dk.mant) { |
254 | 1708 | a10 = FLOAT_0; | |
255 | 1708 | a11 = FLOAT_0; | |
256 | } else { | ||
257 | SoftFloat temp_real, temp_im; | ||
258 | 66390 | temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]), | |
259 | av_mul_sf(phi[0][0][1], phi[1][1][1])), | ||
260 | av_mul_sf(phi[0][1][0], phi[1][0][0])); | ||
261 | 66390 | temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]), | |
262 | av_mul_sf(phi[0][0][1], phi[1][1][0])), | ||
263 | av_mul_sf(phi[0][1][1], phi[1][0][0])); | ||
264 | |||
265 | 66390 | a10 = av_div_sf(temp_real, dk); | |
266 | 66390 | a11 = av_div_sf(temp_im, dk); | |
267 | } | ||
268 | |||
269 |
2/2✓ Branch 0 taken 1708 times.
✓ Branch 1 taken 66390 times.
|
68098 | if (!phi[1][0][0].mant) { |
270 | 1708 | a00 = FLOAT_0; | |
271 | 1708 | a01 = FLOAT_0; | |
272 | } else { | ||
273 | SoftFloat temp_real, temp_im; | ||
274 | 66390 | temp_real = av_add_sf(phi[0][0][0], | |
275 | av_add_sf(av_mul_sf(a10, phi[1][1][0]), | ||
276 | av_mul_sf(a11, phi[1][1][1]))); | ||
277 | 66390 | temp_im = av_add_sf(phi[0][0][1], | |
278 | av_sub_sf(av_mul_sf(a11, phi[1][1][0]), | ||
279 | av_mul_sf(a10, phi[1][1][1]))); | ||
280 | |||
281 | 66390 | temp_real.mant = -temp_real.mant; | |
282 | 66390 | temp_im.mant = -temp_im.mant; | |
283 | 66390 | a00 = av_div_sf(temp_real, phi[1][0][0]); | |
284 | 66390 | a01 = av_div_sf(temp_im, phi[1][0][0]); | |
285 | } | ||
286 | |||
287 | 68098 | shift = a00.exp; | |
288 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 68096 times.
|
68098 | if (shift >= 3) |
289 | 2 | alpha0[k][0] = 0x7fffffff; | |
290 |
2/2✓ Branch 0 taken 2123 times.
✓ Branch 1 taken 65973 times.
|
68096 | else if (shift <= -30) |
291 | 2123 | alpha0[k][0] = 0; | |
292 | else { | ||
293 | 65973 | shift = 1-shift; | |
294 |
2/2✓ Branch 0 taken 1838 times.
✓ Branch 1 taken 64135 times.
|
65973 | if (shift <= 0) |
295 | 1838 | alpha0[k][0] = a00.mant * (1<<-shift); | |
296 | else { | ||
297 | 64135 | round = 1 << (shift-1); | |
298 | 64135 | alpha0[k][0] = (a00.mant + round) >> shift; | |
299 | } | ||
300 | } | ||
301 | |||
302 | 68098 | shift = a01.exp; | |
303 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 68095 times.
|
68098 | if (shift >= 3) |
304 | 3 | alpha0[k][1] = 0x7fffffff; | |
305 |
2/2✓ Branch 0 taken 2078 times.
✓ Branch 1 taken 66017 times.
|
68095 | else if (shift <= -30) |
306 | 2078 | alpha0[k][1] = 0; | |
307 | else { | ||
308 | 66017 | shift = 1-shift; | |
309 |
2/2✓ Branch 0 taken 14382 times.
✓ Branch 1 taken 51635 times.
|
66017 | if (shift <= 0) |
310 | 14382 | alpha0[k][1] = a01.mant * (1<<-shift); | |
311 | else { | ||
312 | 51635 | round = 1 << (shift-1); | |
313 | 51635 | alpha0[k][1] = (a01.mant + round) >> shift; | |
314 | } | ||
315 | } | ||
316 | 68098 | shift = a10.exp; | |
317 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 68093 times.
|
68098 | if (shift >= 3) |
318 | 5 | alpha1[k][0] = 0x7fffffff; | |
319 |
2/2✓ Branch 0 taken 2024 times.
✓ Branch 1 taken 66069 times.
|
68093 | else if (shift <= -30) |
320 | 2024 | alpha1[k][0] = 0; | |
321 | else { | ||
322 | 66069 | shift = 1-shift; | |
323 |
2/2✓ Branch 0 taken 76 times.
✓ Branch 1 taken 65993 times.
|
66069 | if (shift <= 0) |
324 | 76 | alpha1[k][0] = a10.mant * (1<<-shift); | |
325 | else { | ||
326 | 65993 | round = 1 << (shift-1); | |
327 | 65993 | alpha1[k][0] = (a10.mant + round) >> shift; | |
328 | } | ||
329 | } | ||
330 | |||
331 | 68098 | shift = a11.exp; | |
332 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68098 times.
|
68098 | if (shift >= 3) |
333 | ✗ | alpha1[k][1] = 0x7fffffff; | |
334 |
2/2✓ Branch 0 taken 2114 times.
✓ Branch 1 taken 65984 times.
|
68098 | else if (shift <= -30) |
335 | 2114 | alpha1[k][1] = 0; | |
336 | else { | ||
337 | 65984 | shift = 1-shift; | |
338 |
2/2✓ Branch 0 taken 84 times.
✓ Branch 1 taken 65900 times.
|
65984 | if (shift <= 0) |
339 | 84 | alpha1[k][1] = a11.mant * (1<<-shift); | |
340 | else { | ||
341 | 65900 | round = 1 << (shift-1); | |
342 | 65900 | alpha1[k][1] = (a11.mant + round) >> shift; | |
343 | } | ||
344 | } | ||
345 | |||
346 | 68098 | shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \ | |
347 | 68098 | (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \ | |
348 | 68098 | 0x40000000) >> 31); | |
349 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68098 times.
|
68098 | if (shift >= 0x20000000){ |
350 | ✗ | alpha1[k][0] = 0; | |
351 | ✗ | alpha1[k][1] = 0; | |
352 | ✗ | alpha0[k][0] = 0; | |
353 | ✗ | alpha0[k][1] = 0; | |
354 | } | ||
355 | |||
356 | 68098 | shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \ | |
357 | 68098 | (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \ | |
358 | 68098 | 0x40000000) >> 31); | |
359 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68098 times.
|
68098 | if (shift >= 0x20000000){ |
360 | ✗ | alpha1[k][0] = 0; | |
361 | ✗ | alpha1[k][1] = 0; | |
362 | ✗ | alpha0[k][0] = 0; | |
363 | ✗ | alpha0[k][1] = 0; | |
364 | } | ||
365 | } | ||
366 | 3787 | } | |
367 | |||
368 | /// Chirp Factors (14496-3 sp04 p214) | ||
369 | 3787 | static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data) | |
370 | { | ||
371 | int i; | ||
372 | int new_bw; | ||
373 | static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 }; | ||
374 | int64_t accu; | ||
375 | |||
376 |
2/2✓ Branch 0 taken 10213 times.
✓ Branch 1 taken 3787 times.
|
14000 | for (i = 0; i < sbr->n_q; i++) { |
377 |
2/2✓ Branch 0 taken 799 times.
✓ Branch 1 taken 9414 times.
|
10213 | if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) |
378 | 799 | new_bw = 1288490189; | |
379 | else | ||
380 | 9414 | new_bw = bw_tab[ch_data->bs_invf_mode[0][i]]; | |
381 | |||
382 |
2/2✓ Branch 0 taken 2080 times.
✓ Branch 1 taken 8133 times.
|
10213 | if (new_bw < ch_data->bw_array[i]){ |
383 | 2080 | accu = (int64_t)new_bw * 1610612736; | |
384 | 2080 | accu += (int64_t)ch_data->bw_array[i] * 0x20000000; | |
385 | 2080 | new_bw = (int)((accu + 0x40000000) >> 31); | |
386 | } else { | ||
387 | 8133 | accu = (int64_t)new_bw * 1946157056; | |
388 | 8133 | accu += (int64_t)ch_data->bw_array[i] * 201326592; | |
389 | 8133 | new_bw = (int)((accu + 0x40000000) >> 31); | |
390 | } | ||
391 |
2/2✓ Branch 0 taken 7712 times.
✓ Branch 1 taken 2501 times.
|
10213 | ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw; |
392 | } | ||
393 | 3787 | } | |
394 | |||
395 | /** | ||
396 | * Calculation of levels of additional HF signal components (14496-3 sp04 p219) | ||
397 | * and Calculation of gain (14496-3 sp04 p219) | ||
398 | */ | ||
399 | 3787 | static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr, | |
400 | SBRData *ch_data, const int e_a[2]) | ||
401 | { | ||
402 | int e, k, m; | ||
403 | // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off) | ||
404 | static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 }, | ||
405 | { 758351638, 1 }, { 625000000, 34 } }; | ||
406 | |||
407 |
2/2✓ Branch 0 taken 5588 times.
✓ Branch 1 taken 3787 times.
|
9375 | for (e = 0; e < ch_data->bs_num_env; e++) { |
408 |
4/4✓ Branch 0 taken 5309 times.
✓ Branch 1 taken 279 times.
✓ Branch 2 taken 5226 times.
✓ Branch 3 taken 83 times.
|
5588 | int delta = !((e == e_a[1]) || (e == e_a[0])); |
409 |
2/2✓ Branch 0 taken 17704 times.
✓ Branch 1 taken 5588 times.
|
23292 | for (k = 0; k < sbr->n_lim; k++) { |
410 | SoftFloat gain_boost, gain_max; | ||
411 | SoftFloat sum[2]; | ||
412 | 17704 | sum[0] = sum[1] = FLOAT_0; | |
413 |
2/2✓ Branch 0 taken 127837 times.
✓ Branch 1 taken 17704 times.
|
145541 | for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { |
414 | 127837 | const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m], | |
415 | av_add_sf(FLOAT_1, sbr->q_mapped[e][m])); | ||
416 | 127837 | sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m])); | |
417 | 127837 | sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0))); | |
418 |
2/2✓ Branch 0 taken 123205 times.
✓ Branch 1 taken 4632 times.
|
127837 | if (!sbr->s_mapped[e][m]) { |
419 |
2/2✓ Branch 0 taken 115357 times.
✓ Branch 1 taken 7848 times.
|
123205 | if (delta) { |
420 | 115357 | sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m], | |
421 | av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]), | ||
422 | av_add_sf(FLOAT_1, sbr->q_mapped[e][m])))); | ||
423 | } else { | ||
424 | 7848 | sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m], | |
425 | av_add_sf(FLOAT_1, sbr->e_curr[e][m]))); | ||
426 | } | ||
427 | } else { | ||
428 | 4632 | sbr->gain[e][m] = av_sqrt_sf( | |
429 | av_div_sf( | ||
430 | av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]), | ||
431 | av_mul_sf( | ||
432 | av_add_sf(FLOAT_1, sbr->e_curr[e][m]), | ||
433 | av_add_sf(FLOAT_1, sbr->q_mapped[e][m])))); | ||
434 | } | ||
435 | 127837 | sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN); | |
436 | } | ||
437 |
2/2✓ Branch 0 taken 127837 times.
✓ Branch 1 taken 17704 times.
|
145541 | for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { |
438 | 127837 | sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]); | |
439 | 127837 | sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]); | |
440 | } | ||
441 | 17704 | gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains], | |
442 | av_sqrt_sf( | ||
443 | av_div_sf( | ||
444 | av_add_sf(FLOAT_EPSILON, sum[0]), | ||
445 | av_add_sf(FLOAT_EPSILON, sum[1])))); | ||
446 |
2/2✓ Branch 0 taken 3741 times.
✓ Branch 1 taken 13963 times.
|
17704 | if (av_gt_sf(gain_max, FLOAT_100000)) |
447 | 3741 | gain_max = FLOAT_100000; | |
448 |
2/2✓ Branch 0 taken 127837 times.
✓ Branch 1 taken 17704 times.
|
145541 | for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { |
449 | 127837 | SoftFloat q_m_max = av_div_sf( | |
450 | av_mul_sf(sbr->q_m[e][m], gain_max), | ||
451 | sbr->gain[e][m]); | ||
452 |
2/2✓ Branch 0 taken 33577 times.
✓ Branch 1 taken 94260 times.
|
127837 | if (av_gt_sf(sbr->q_m[e][m], q_m_max)) |
453 | 33577 | sbr->q_m[e][m] = q_m_max; | |
454 |
2/2✓ Branch 0 taken 33577 times.
✓ Branch 1 taken 94260 times.
|
127837 | if (av_gt_sf(sbr->gain[e][m], gain_max)) |
455 | 33577 | sbr->gain[e][m] = gain_max; | |
456 | } | ||
457 | 17704 | sum[0] = sum[1] = FLOAT_0; | |
458 |
2/2✓ Branch 0 taken 127837 times.
✓ Branch 1 taken 17704 times.
|
145541 | for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { |
459 | 127837 | sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]); | |
460 | 127837 | sum[1] = av_add_sf(sum[1], | |
461 | av_mul_sf( | ||
462 | av_mul_sf(sbr->e_curr[e][m], | ||
463 | sbr->gain[e][m]), | ||
464 | sbr->gain[e][m])); | ||
465 | 127837 | sum[1] = av_add_sf(sum[1], | |
466 | av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m])); | ||
467 |
4/4✓ Branch 0 taken 119187 times.
✓ Branch 1 taken 8650 times.
✓ Branch 2 taken 117689 times.
✓ Branch 3 taken 1498 times.
|
127837 | if (delta && !sbr->s_m[e][m].mant) |
468 | 117689 | sum[1] = av_add_sf(sum[1], | |
469 | av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m])); | ||
470 | } | ||
471 | 17704 | gain_boost = av_sqrt_sf( | |
472 | av_div_sf( | ||
473 | av_add_sf(FLOAT_EPSILON, sum[0]), | ||
474 | av_add_sf(FLOAT_EPSILON, sum[1]))); | ||
475 |
2/2✓ Branch 0 taken 1483 times.
✓ Branch 1 taken 16221 times.
|
17704 | if (av_gt_sf(gain_boost, FLOAT_1584893192)) |
476 | 1483 | gain_boost = FLOAT_1584893192; | |
477 | |||
478 |
2/2✓ Branch 0 taken 127837 times.
✓ Branch 1 taken 17704 times.
|
145541 | for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { |
479 | 127837 | sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost); | |
480 | 127837 | sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost); | |
481 | 127837 | sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost); | |
482 | } | ||
483 | } | ||
484 | } | ||
485 | 3787 | } | |
486 | |||
487 | /// Assembling HF Signals (14496-3 sp04 p220) | ||
488 | 3787 | static void sbr_hf_assemble(int Y1[38][64][2], | |
489 | const int X_high[64][40][2], | ||
490 | SpectralBandReplication *sbr, SBRData *ch_data, | ||
491 | const int e_a[2]) | ||
492 | { | ||
493 | int e, i, j, m; | ||
494 |
2/2✓ Branch 0 taken 1148 times.
✓ Branch 1 taken 2639 times.
|
3787 | const int h_SL = 4 * !sbr->bs_smoothing_mode; |
495 | 3787 | const int kx = sbr->kx[1]; | |
496 | 3787 | const int m_max = sbr->m[1]; | |
497 | static const SoftFloat h_smooth[5] = { | ||
498 | { 715827883, -1 }, | ||
499 | { 647472402, -1 }, | ||
500 | { 937030863, -2 }, | ||
501 | { 989249804, -3 }, | ||
502 | { 546843842, -4 }, | ||
503 | }; | ||
504 | 3787 | SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp; | |
505 | 3787 | int indexnoise = ch_data->f_indexnoise; | |
506 | 3787 | int indexsine = ch_data->f_indexsine; | |
507 | |||
508 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 3778 times.
|
3787 | if (sbr->reset) { |
509 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 9 times.
|
17 | for (i = 0; i < h_SL; i++) { |
510 | 8 | memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0])); | |
511 | 8 | memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0])); | |
512 | } | ||
513 |
2/2✓ Branch 0 taken 1146 times.
✓ Branch 1 taken 2632 times.
|
3778 | } else if (h_SL) { |
514 |
2/2✓ Branch 0 taken 4584 times.
✓ Branch 1 taken 1146 times.
|
5730 | for (i = 0; i < 4; i++) { |
515 | 4584 | memcpy(g_temp[i + 2 * ch_data->t_env[0]], | |
516 | 4584 | g_temp[i + 2 * ch_data->t_env_num_env_old], | |
517 | sizeof(g_temp[0])); | ||
518 | 4584 | memcpy(q_temp[i + 2 * ch_data->t_env[0]], | |
519 | 4584 | q_temp[i + 2 * ch_data->t_env_num_env_old], | |
520 | sizeof(q_temp[0])); | ||
521 | } | ||
522 | } | ||
523 | |||
524 |
2/2✓ Branch 0 taken 5588 times.
✓ Branch 1 taken 3787 times.
|
9375 | for (e = 0; e < ch_data->bs_num_env; e++) { |
525 |
2/2✓ Branch 0 taken 121184 times.
✓ Branch 1 taken 5588 times.
|
126772 | for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { |
526 | 121184 | memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0])); | |
527 | 121184 | memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0])); | |
528 | } | ||
529 | } | ||
530 | |||
531 |
2/2✓ Branch 0 taken 5588 times.
✓ Branch 1 taken 3787 times.
|
9375 | for (e = 0; e < ch_data->bs_num_env; e++) { |
532 |
2/2✓ Branch 0 taken 121184 times.
✓ Branch 1 taken 5588 times.
|
126772 | for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { |
533 | SoftFloat g_filt_tab[48]; | ||
534 | SoftFloat q_filt_tab[48]; | ||
535 | SoftFloat *g_filt, *q_filt; | ||
536 | |||
537 |
6/6✓ Branch 0 taken 36736 times.
✓ Branch 1 taken 84448 times.
✓ Branch 2 taken 36694 times.
✓ Branch 3 taken 42 times.
✓ Branch 4 taken 36634 times.
✓ Branch 5 taken 60 times.
|
121184 | if (h_SL && e != e_a[0] && e != e_a[1]) { |
538 | 36634 | g_filt = g_filt_tab; | |
539 | 36634 | q_filt = q_filt_tab; | |
540 |
2/2✓ Branch 0 taken 622778 times.
✓ Branch 1 taken 36634 times.
|
659412 | for (m = 0; m < m_max; m++) { |
541 | 622778 | const int idx1 = i + h_SL; | |
542 | 622778 | g_filt[m].mant = g_filt[m].exp = 0; | |
543 | 622778 | q_filt[m].mant = q_filt[m].exp = 0; | |
544 |
2/2✓ Branch 0 taken 3113890 times.
✓ Branch 1 taken 622778 times.
|
3736668 | for (j = 0; j <= h_SL; j++) { |
545 | 3113890 | g_filt[m] = av_add_sf(g_filt[m], | |
546 | 3113890 | av_mul_sf(g_temp[idx1 - j][m], | |
547 | h_smooth[j])); | ||
548 | 3113890 | q_filt[m] = av_add_sf(q_filt[m], | |
549 | 3113890 | av_mul_sf(q_temp[idx1 - j][m], | |
550 | h_smooth[j])); | ||
551 | } | ||
552 | } | ||
553 | } else { | ||
554 | 84550 | g_filt = g_temp[i + h_SL]; | |
555 | 84550 | q_filt = q_temp[i]; | |
556 | } | ||
557 | |||
558 | 121184 | sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max, | |
559 | 121184 | i + ENVELOPE_ADJUSTMENT_OFFSET); | |
560 | |||
561 |
4/4✓ Branch 0 taken 120826 times.
✓ Branch 1 taken 358 times.
✓ Branch 2 taken 119686 times.
✓ Branch 3 taken 1140 times.
|
121184 | if (e != e_a[0] && e != e_a[1]) { |
562 | 119686 | sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e], | |
563 | q_filt, indexnoise, | ||
564 | kx, m_max); | ||
565 | } else { | ||
566 | 1498 | int idx = indexsine&1; | |
567 | 1498 | int A = (1-((indexsine+(kx & 1))&2)); | |
568 | 1498 | int B = (A^(-idx)) + idx; | |
569 | 1498 | unsigned *out = &Y1[i][kx][idx]; | |
570 | int shift; | ||
571 | unsigned round; | ||
572 | |||
573 | 1498 | SoftFloat *in = sbr->s_m[e]; | |
574 |
2/2✓ Branch 0 taken 17400 times.
✓ Branch 1 taken 1498 times.
|
18898 | for (m = 0; m+1 < m_max; m+=2) { |
575 | int shift2; | ||
576 | 17400 | shift = 22 - in[m ].exp; | |
577 | 17400 | shift2= 22 - in[m+1].exp; | |
578 |
2/4✓ Branch 0 taken 17400 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17400 times.
|
17400 | if (shift < 1 || shift2 < 1) { |
579 | ✗ | av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2); | |
580 | ✗ | return; | |
581 | } | ||
582 |
2/2✓ Branch 0 taken 600 times.
✓ Branch 1 taken 16800 times.
|
17400 | if (shift < 32) { |
583 | 600 | round = 1 << (shift-1); | |
584 | 600 | out[2*m ] += (int)(in[m ].mant * A + round) >> shift; | |
585 | } | ||
586 | |||
587 |
2/2✓ Branch 0 taken 152 times.
✓ Branch 1 taken 17248 times.
|
17400 | if (shift2 < 32) { |
588 | 152 | round = 1 << (shift2-1); | |
589 | 152 | out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2; | |
590 | } | ||
591 | } | ||
592 |
2/2✓ Branch 0 taken 1004 times.
✓ Branch 1 taken 494 times.
|
1498 | if(m_max&1) |
593 | { | ||
594 | 1004 | shift = 22 - in[m ].exp; | |
595 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1004 times.
|
1004 | if (shift < 1) { |
596 | ✗ | av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift); | |
597 | ✗ | return; | |
598 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1004 times.
|
1004 | } else if (shift < 32) { |
599 | ✗ | round = 1 << (shift-1); | |
600 | ✗ | out[2*m ] += (int)(in[m ].mant * A + round) >> shift; | |
601 | } | ||
602 | } | ||
603 | } | ||
604 | 121184 | indexnoise = (indexnoise + m_max) & 0x1ff; | |
605 | 121184 | indexsine = (indexsine + 1) & 3; | |
606 | } | ||
607 | } | ||
608 | 3787 | ch_data->f_indexnoise = indexnoise; | |
609 | 3787 | ch_data->f_indexsine = indexsine; | |
610 | } | ||
611 | |||
612 | #include "aacsbr_template.c" | ||
613 |