1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
5 Forschung e.V. All rights reserved.
6
7 1. INTRODUCTION
8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
10 scheme for digital audio. This FDK AAC Codec software is intended to be used on
11 a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
14 general perceptual audio codecs. AAC-ELD is considered the best-performing
15 full-bandwidth communications codec by independent studies and is widely
16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG
17 specifications.
18
19 Patent licenses for necessary patent claims for the FDK AAC Codec (including
20 those of Fraunhofer) may be obtained through Via Licensing
21 (www.vialicensing.com) or through the respective patent owners individually for
22 the purpose of encoding or decoding bit streams in products that are compliant
23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
24 Android devices already license these patent claims through Via Licensing or
25 directly from the patent owners, and therefore FDK AAC Codec software may
26 already be covered under those patent licenses when it is used for those
27 licensed purposes only.
28
29 Commercially-licensed AAC software libraries, including floating-point versions
30 with enhanced sound quality, are also available from Fraunhofer. Users are
31 encouraged to check the Fraunhofer website for additional applications
32 information and documentation.
33
34 2. COPYRIGHT LICENSE
35
36 Redistribution and use in source and binary forms, with or without modification,
37 are permitted without payment of copyright license fees provided that you
38 satisfy the following conditions:
39
40 You must retain the complete text of this software license in redistributions of
41 the FDK AAC Codec or your modifications thereto in source code form.
42
43 You must retain the complete text of this software license in the documentation
44 and/or other materials provided with redistributions of the FDK AAC Codec or
45 your modifications thereto in binary form. You must make available free of
46 charge copies of the complete source code of the FDK AAC Codec and your
47 modifications thereto to recipients of copies in binary form.
48
49 The name of Fraunhofer may not be used to endorse or promote products derived
50 from this library without prior written permission.
51
52 You may not charge copyright license fees for anyone to use, copy or distribute
53 the FDK AAC Codec software or your modifications thereto.
54
55 Your modified versions of the FDK AAC Codec must carry prominent notices stating
56 that you changed the software and the date of any change. For modified versions
57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
59 AAC Codec Library for Android."
60
61 3. NO PATENT LICENSE
62
63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
65 Fraunhofer provides no warranty of patent non-infringement with respect to this
66 software.
67
68 You may use this FDK AAC Codec software or modifications thereto only for
69 purposes that are authorized by appropriate patent licenses.
70
71 4. DISCLAIMER
72
73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
75 including but not limited to the implied warranties of merchantability and
76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
78 or consequential damages, including but not limited to procurement of substitute
79 goods or services; loss of use, data, or profits, or business interruption,
80 however caused and on any theory of liability, whether in contract, strict
81 liability, or tort (including negligence), arising in any way out of the use of
82 this software, even if advised of the possibility of such damage.
83
84 5. CONTACT INFORMATION
85
86 Fraunhofer Institute for Integrated Circuits IIS
87 Attention: Audio and Multimedia Departments - FDK AAC LL
88 Am Wolfsmantel 33
89 91058 Erlangen, Germany
90
91 www.iis.fraunhofer.de/amm
92 amm-info@iis.fraunhofer.de
93 ----------------------------------------------------------------------------- */
94
95 /**************************** SBR decoder library ******************************
96
97 Author(s):
98
99 Description:
100
101 *******************************************************************************/
102
103 /*!
104 \file
105 \brief Fast FFT routines prototypes
106 \author Fabian Haussel
107 */
108
109 #include "hbe.h"
110 #include "qmf.h"
111 #include "env_extr.h"
112
113 #define HBE_MAX_QMF_BANDS (40)
114
115 #define HBE_MAX_OUT_SLOTS (11)
116
117 #define QMF_WIN_LEN \
118 (12 + 6 - 4 - 1) /* 6 subband slots extra delay to align with HQ - 4 slots \
119 to compensate for critical sampling delay - 1 slot to \
120 align critical sampling exactly (w additional time \
121 domain delay)*/
122
123 #ifndef PI
124 #define PI 3.14159265358979323846
125 #endif
126
127 static const int xProducts[MAX_STRETCH_HBE - 1] = {
128 1, 1, 1}; /* Cross products on(1)/off(0) for T=2,3,4. */
129 static const int startSubband2kL[33] = {
130 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6,
131 6, 8, 8, 8, 8, 8, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12};
132
133 static const int pmin = 12;
134
135 static const FIXP_DBL hintReal_F[4][3] = {
136 {FL2FXCONST_DBL(0.39840335f), FL2FXCONST_DBL(0.39840335f),
137 FL2FXCONST_DBL(-0.39840335f)},
138 {FL2FXCONST_DBL(0.39840335f), FL2FXCONST_DBL(-0.39840335f),
139 FL2FXCONST_DBL(-0.39840335f)},
140 {FL2FXCONST_DBL(-0.39840335f), FL2FXCONST_DBL(-0.39840335f),
141 FL2FXCONST_DBL(0.39840335f)},
142 {FL2FXCONST_DBL(-0.39840335f), FL2FXCONST_DBL(0.39840335f),
143 FL2FXCONST_DBL(0.39840335f)}};
144
145 static const FIXP_DBL factors[4] = {
146 FL2FXCONST_DBL(0.39840335f), FL2FXCONST_DBL(-0.39840335f),
147 FL2FXCONST_DBL(-0.39840335f), FL2FXCONST_DBL(0.39840335f)};
148
149 #define PSCALE 32
150
151 static const FIXP_DBL p_F[128] = {FL2FXCONST_DBL(0.f / (PSCALE * 12.f)),
152 FL2FXCONST_DBL(1.f / (PSCALE * 12.f)),
153 FL2FXCONST_DBL(2.f / (PSCALE * 12.f)),
154 FL2FXCONST_DBL(3.f / (PSCALE * 12.f)),
155 FL2FXCONST_DBL(4.f / (PSCALE * 12.f)),
156 FL2FXCONST_DBL(5.f / (PSCALE * 12.f)),
157 FL2FXCONST_DBL(6.f / (PSCALE * 12.f)),
158 FL2FXCONST_DBL(7.f / (PSCALE * 12.f)),
159 FL2FXCONST_DBL(8.f / (PSCALE * 12.f)),
160 FL2FXCONST_DBL(9.f / (PSCALE * 12.f)),
161 FL2FXCONST_DBL(10.f / (PSCALE * 12.f)),
162 FL2FXCONST_DBL(11.f / (PSCALE * 12.f)),
163 FL2FXCONST_DBL(12.f / (PSCALE * 12.f)),
164 FL2FXCONST_DBL(13.f / (PSCALE * 12.f)),
165 FL2FXCONST_DBL(14.f / (PSCALE * 12.f)),
166 FL2FXCONST_DBL(15.f / (PSCALE * 12.f)),
167 FL2FXCONST_DBL(16.f / (PSCALE * 12.f)),
168 FL2FXCONST_DBL(17.f / (PSCALE * 12.f)),
169 FL2FXCONST_DBL(18.f / (PSCALE * 12.f)),
170 FL2FXCONST_DBL(19.f / (PSCALE * 12.f)),
171 FL2FXCONST_DBL(20.f / (PSCALE * 12.f)),
172 FL2FXCONST_DBL(21.f / (PSCALE * 12.f)),
173 FL2FXCONST_DBL(22.f / (PSCALE * 12.f)),
174 FL2FXCONST_DBL(23.f / (PSCALE * 12.f)),
175 FL2FXCONST_DBL(24.f / (PSCALE * 12.f)),
176 FL2FXCONST_DBL(25.f / (PSCALE * 12.f)),
177 FL2FXCONST_DBL(26.f / (PSCALE * 12.f)),
178 FL2FXCONST_DBL(27.f / (PSCALE * 12.f)),
179 FL2FXCONST_DBL(28.f / (PSCALE * 12.f)),
180 FL2FXCONST_DBL(29.f / (PSCALE * 12.f)),
181 FL2FXCONST_DBL(30.f / (PSCALE * 12.f)),
182 FL2FXCONST_DBL(31.f / (PSCALE * 12.f)),
183 FL2FXCONST_DBL(32.f / (PSCALE * 12.f)),
184 FL2FXCONST_DBL(33.f / (PSCALE * 12.f)),
185 FL2FXCONST_DBL(34.f / (PSCALE * 12.f)),
186 FL2FXCONST_DBL(35.f / (PSCALE * 12.f)),
187 FL2FXCONST_DBL(36.f / (PSCALE * 12.f)),
188 FL2FXCONST_DBL(37.f / (PSCALE * 12.f)),
189 FL2FXCONST_DBL(38.f / (PSCALE * 12.f)),
190 FL2FXCONST_DBL(39.f / (PSCALE * 12.f)),
191 FL2FXCONST_DBL(40.f / (PSCALE * 12.f)),
192 FL2FXCONST_DBL(41.f / (PSCALE * 12.f)),
193 FL2FXCONST_DBL(42.f / (PSCALE * 12.f)),
194 FL2FXCONST_DBL(43.f / (PSCALE * 12.f)),
195 FL2FXCONST_DBL(44.f / (PSCALE * 12.f)),
196 FL2FXCONST_DBL(45.f / (PSCALE * 12.f)),
197 FL2FXCONST_DBL(46.f / (PSCALE * 12.f)),
198 FL2FXCONST_DBL(47.f / (PSCALE * 12.f)),
199 FL2FXCONST_DBL(48.f / (PSCALE * 12.f)),
200 FL2FXCONST_DBL(49.f / (PSCALE * 12.f)),
201 FL2FXCONST_DBL(50.f / (PSCALE * 12.f)),
202 FL2FXCONST_DBL(51.f / (PSCALE * 12.f)),
203 FL2FXCONST_DBL(52.f / (PSCALE * 12.f)),
204 FL2FXCONST_DBL(53.f / (PSCALE * 12.f)),
205 FL2FXCONST_DBL(54.f / (PSCALE * 12.f)),
206 FL2FXCONST_DBL(55.f / (PSCALE * 12.f)),
207 FL2FXCONST_DBL(56.f / (PSCALE * 12.f)),
208 FL2FXCONST_DBL(57.f / (PSCALE * 12.f)),
209 FL2FXCONST_DBL(58.f / (PSCALE * 12.f)),
210 FL2FXCONST_DBL(59.f / (PSCALE * 12.f)),
211 FL2FXCONST_DBL(60.f / (PSCALE * 12.f)),
212 FL2FXCONST_DBL(61.f / (PSCALE * 12.f)),
213 FL2FXCONST_DBL(62.f / (PSCALE * 12.f)),
214 FL2FXCONST_DBL(63.f / (PSCALE * 12.f)),
215 FL2FXCONST_DBL(64.f / (PSCALE * 12.f)),
216 FL2FXCONST_DBL(65.f / (PSCALE * 12.f)),
217 FL2FXCONST_DBL(66.f / (PSCALE * 12.f)),
218 FL2FXCONST_DBL(67.f / (PSCALE * 12.f)),
219 FL2FXCONST_DBL(68.f / (PSCALE * 12.f)),
220 FL2FXCONST_DBL(69.f / (PSCALE * 12.f)),
221 FL2FXCONST_DBL(70.f / (PSCALE * 12.f)),
222 FL2FXCONST_DBL(71.f / (PSCALE * 12.f)),
223 FL2FXCONST_DBL(72.f / (PSCALE * 12.f)),
224 FL2FXCONST_DBL(73.f / (PSCALE * 12.f)),
225 FL2FXCONST_DBL(74.f / (PSCALE * 12.f)),
226 FL2FXCONST_DBL(75.f / (PSCALE * 12.f)),
227 FL2FXCONST_DBL(76.f / (PSCALE * 12.f)),
228 FL2FXCONST_DBL(77.f / (PSCALE * 12.f)),
229 FL2FXCONST_DBL(78.f / (PSCALE * 12.f)),
230 FL2FXCONST_DBL(79.f / (PSCALE * 12.f)),
231 FL2FXCONST_DBL(80.f / (PSCALE * 12.f)),
232 FL2FXCONST_DBL(81.f / (PSCALE * 12.f)),
233 FL2FXCONST_DBL(82.f / (PSCALE * 12.f)),
234 FL2FXCONST_DBL(83.f / (PSCALE * 12.f)),
235 FL2FXCONST_DBL(84.f / (PSCALE * 12.f)),
236 FL2FXCONST_DBL(85.f / (PSCALE * 12.f)),
237 FL2FXCONST_DBL(86.f / (PSCALE * 12.f)),
238 FL2FXCONST_DBL(87.f / (PSCALE * 12.f)),
239 FL2FXCONST_DBL(88.f / (PSCALE * 12.f)),
240 FL2FXCONST_DBL(89.f / (PSCALE * 12.f)),
241 FL2FXCONST_DBL(90.f / (PSCALE * 12.f)),
242 FL2FXCONST_DBL(91.f / (PSCALE * 12.f)),
243 FL2FXCONST_DBL(92.f / (PSCALE * 12.f)),
244 FL2FXCONST_DBL(93.f / (PSCALE * 12.f)),
245 FL2FXCONST_DBL(94.f / (PSCALE * 12.f)),
246 FL2FXCONST_DBL(95.f / (PSCALE * 12.f)),
247 FL2FXCONST_DBL(96.f / (PSCALE * 12.f)),
248 FL2FXCONST_DBL(97.f / (PSCALE * 12.f)),
249 FL2FXCONST_DBL(98.f / (PSCALE * 12.f)),
250 FL2FXCONST_DBL(99.f / (PSCALE * 12.f)),
251 FL2FXCONST_DBL(100.f / (PSCALE * 12.f)),
252 FL2FXCONST_DBL(101.f / (PSCALE * 12.f)),
253 FL2FXCONST_DBL(102.f / (PSCALE * 12.f)),
254 FL2FXCONST_DBL(103.f / (PSCALE * 12.f)),
255 FL2FXCONST_DBL(104.f / (PSCALE * 12.f)),
256 FL2FXCONST_DBL(105.f / (PSCALE * 12.f)),
257 FL2FXCONST_DBL(106.f / (PSCALE * 12.f)),
258 FL2FXCONST_DBL(107.f / (PSCALE * 12.f)),
259 FL2FXCONST_DBL(108.f / (PSCALE * 12.f)),
260 FL2FXCONST_DBL(109.f / (PSCALE * 12.f)),
261 FL2FXCONST_DBL(110.f / (PSCALE * 12.f)),
262 FL2FXCONST_DBL(111.f / (PSCALE * 12.f)),
263 FL2FXCONST_DBL(112.f / (PSCALE * 12.f)),
264 FL2FXCONST_DBL(113.f / (PSCALE * 12.f)),
265 FL2FXCONST_DBL(114.f / (PSCALE * 12.f)),
266 FL2FXCONST_DBL(115.f / (PSCALE * 12.f)),
267 FL2FXCONST_DBL(116.f / (PSCALE * 12.f)),
268 FL2FXCONST_DBL(117.f / (PSCALE * 12.f)),
269 FL2FXCONST_DBL(118.f / (PSCALE * 12.f)),
270 FL2FXCONST_DBL(119.f / (PSCALE * 12.f)),
271 FL2FXCONST_DBL(120.f / (PSCALE * 12.f)),
272 FL2FXCONST_DBL(121.f / (PSCALE * 12.f)),
273 FL2FXCONST_DBL(122.f / (PSCALE * 12.f)),
274 FL2FXCONST_DBL(123.f / (PSCALE * 12.f)),
275 FL2FXCONST_DBL(124.f / (PSCALE * 12.f)),
276 FL2FXCONST_DBL(125.f / (PSCALE * 12.f)),
277 FL2FXCONST_DBL(126.f / (PSCALE * 12.f)),
278 FL2FXCONST_DBL(127.f / (PSCALE * 12.f))};
279
280 static const FIXP_DBL band_F[64] = {
281 FL2FXCONST_DBL((0.f * 2.f + 1) / (PSCALE << 2)),
282 FL2FXCONST_DBL((1.f * 2.f + 1) / (PSCALE << 2)),
283 FL2FXCONST_DBL((2.f * 2.f + 1) / (PSCALE << 2)),
284 FL2FXCONST_DBL((3.f * 2.f + 1) / (PSCALE << 2)),
285 FL2FXCONST_DBL((4.f * 2.f + 1) / (PSCALE << 2)),
286 FL2FXCONST_DBL((5.f * 2.f + 1) / (PSCALE << 2)),
287 FL2FXCONST_DBL((6.f * 2.f + 1) / (PSCALE << 2)),
288 FL2FXCONST_DBL((7.f * 2.f + 1) / (PSCALE << 2)),
289 FL2FXCONST_DBL((8.f * 2.f + 1) / (PSCALE << 2)),
290 FL2FXCONST_DBL((9.f * 2.f + 1) / (PSCALE << 2)),
291 FL2FXCONST_DBL((10.f * 2.f + 1) / (PSCALE << 2)),
292 FL2FXCONST_DBL((11.f * 2.f + 1) / (PSCALE << 2)),
293 FL2FXCONST_DBL((12.f * 2.f + 1) / (PSCALE << 2)),
294 FL2FXCONST_DBL((13.f * 2.f + 1) / (PSCALE << 2)),
295 FL2FXCONST_DBL((14.f * 2.f + 1) / (PSCALE << 2)),
296 FL2FXCONST_DBL((15.f * 2.f + 1) / (PSCALE << 2)),
297 FL2FXCONST_DBL((16.f * 2.f + 1) / (PSCALE << 2)),
298 FL2FXCONST_DBL((17.f * 2.f + 1) / (PSCALE << 2)),
299 FL2FXCONST_DBL((18.f * 2.f + 1) / (PSCALE << 2)),
300 FL2FXCONST_DBL((19.f * 2.f + 1) / (PSCALE << 2)),
301 FL2FXCONST_DBL((20.f * 2.f + 1) / (PSCALE << 2)),
302 FL2FXCONST_DBL((21.f * 2.f + 1) / (PSCALE << 2)),
303 FL2FXCONST_DBL((22.f * 2.f + 1) / (PSCALE << 2)),
304 FL2FXCONST_DBL((23.f * 2.f + 1) / (PSCALE << 2)),
305 FL2FXCONST_DBL((24.f * 2.f + 1) / (PSCALE << 2)),
306 FL2FXCONST_DBL((25.f * 2.f + 1) / (PSCALE << 2)),
307 FL2FXCONST_DBL((26.f * 2.f + 1) / (PSCALE << 2)),
308 FL2FXCONST_DBL((27.f * 2.f + 1) / (PSCALE << 2)),
309 FL2FXCONST_DBL((28.f * 2.f + 1) / (PSCALE << 2)),
310 FL2FXCONST_DBL((29.f * 2.f + 1) / (PSCALE << 2)),
311 FL2FXCONST_DBL((30.f * 2.f + 1) / (PSCALE << 2)),
312 FL2FXCONST_DBL((31.f * 2.f + 1) / (PSCALE << 2)),
313 FL2FXCONST_DBL((32.f * 2.f + 1) / (PSCALE << 2)),
314 FL2FXCONST_DBL((33.f * 2.f + 1) / (PSCALE << 2)),
315 FL2FXCONST_DBL((34.f * 2.f + 1) / (PSCALE << 2)),
316 FL2FXCONST_DBL((35.f * 2.f + 1) / (PSCALE << 2)),
317 FL2FXCONST_DBL((36.f * 2.f + 1) / (PSCALE << 2)),
318 FL2FXCONST_DBL((37.f * 2.f + 1) / (PSCALE << 2)),
319 FL2FXCONST_DBL((38.f * 2.f + 1) / (PSCALE << 2)),
320 FL2FXCONST_DBL((39.f * 2.f + 1) / (PSCALE << 2)),
321 FL2FXCONST_DBL((40.f * 2.f + 1) / (PSCALE << 2)),
322 FL2FXCONST_DBL((41.f * 2.f + 1) / (PSCALE << 2)),
323 FL2FXCONST_DBL((42.f * 2.f + 1) / (PSCALE << 2)),
324 FL2FXCONST_DBL((43.f * 2.f + 1) / (PSCALE << 2)),
325 FL2FXCONST_DBL((44.f * 2.f + 1) / (PSCALE << 2)),
326 FL2FXCONST_DBL((45.f * 2.f + 1) / (PSCALE << 2)),
327 FL2FXCONST_DBL((46.f * 2.f + 1) / (PSCALE << 2)),
328 FL2FXCONST_DBL((47.f * 2.f + 1) / (PSCALE << 2)),
329 FL2FXCONST_DBL((48.f * 2.f + 1) / (PSCALE << 2)),
330 FL2FXCONST_DBL((49.f * 2.f + 1) / (PSCALE << 2)),
331 FL2FXCONST_DBL((50.f * 2.f + 1) / (PSCALE << 2)),
332 FL2FXCONST_DBL((51.f * 2.f + 1) / (PSCALE << 2)),
333 FL2FXCONST_DBL((52.f * 2.f + 1) / (PSCALE << 2)),
334 FL2FXCONST_DBL((53.f * 2.f + 1) / (PSCALE << 2)),
335 FL2FXCONST_DBL((54.f * 2.f + 1) / (PSCALE << 2)),
336 FL2FXCONST_DBL((55.f * 2.f + 1) / (PSCALE << 2)),
337 FL2FXCONST_DBL((56.f * 2.f + 1) / (PSCALE << 2)),
338 FL2FXCONST_DBL((57.f * 2.f + 1) / (PSCALE << 2)),
339 FL2FXCONST_DBL((58.f * 2.f + 1) / (PSCALE << 2)),
340 FL2FXCONST_DBL((59.f * 2.f + 1) / (PSCALE << 2)),
341 FL2FXCONST_DBL((60.f * 2.f + 1) / (PSCALE << 2)),
342 FL2FXCONST_DBL((61.f * 2.f + 1) / (PSCALE << 2)),
343 FL2FXCONST_DBL((62.f * 2.f + 1) / (PSCALE << 2)),
344 FL2FXCONST_DBL((63.f * 2.f + 1) / (PSCALE << 2))};
345
346 static const FIXP_DBL tr_str[3] = {FL2FXCONST_DBL(1.f / 4.f),
347 FL2FXCONST_DBL(2.f / 4.f),
348 FL2FXCONST_DBL(3.f / 4.f)};
349
350 static const FIXP_DBL stretchfac[3] = {FL2FXCONST_DBL(1.f / 2.f),
351 FL2FXCONST_DBL(1.f / 3.f),
352 FL2FXCONST_DBL(1.f / 4.f)};
353
354 static const FIXP_DBL cos_F[64] = {
355 26353028, -79043208, 131685776, -184244944, 236697216, -289006912,
356 341142496, -393072608, 444773984, -496191392, 547325824, -598114752,
357 648559104, -698597248, 748230016, -797411904, 846083200, -894275136,
358 941928192, -989013760, 1035474624, -1081340672, 1126555136, -1171063296,
359 1214893696, -1257992192, 1300332544, -1341889408, 1382612736, -1422503808,
360 1461586944, -1499741440, 1537039104, -1573364864, 1608743808, -1643196672,
361 1676617344, -1709028992, 1740450560, -1770784896, 1800089472, -1828273536,
362 1855357440, -1881356288, 1906190080, -1929876608, 1952428928, -1973777664,
363 1993962880, -2012922240, 2030670208, -2047216000, 2062508288, -2076559488,
364 2089376128, -2100932224, 2111196800, -2120214784, 2127953792, -2134394368,
365 2139565056, -2143444864, 2146026624, -2147321856};
366
367 static const FIXP_DBL twiddle[121] = {1073741824,
368 1071442860,
369 1064555814,
370 1053110176,
371 1037154959,
372 1016758484,
373 992008094,
374 963009773,
375 929887697,
376 892783698,
377 851856663,
378 807281846,
379 759250125,
380 707967178,
381 653652607,
382 596538995,
383 536870912,
384 474903865,
385 410903207,
386 345142998,
387 277904834,
388 209476638,
389 140151432,
390 70226075,
391 0,
392 -70226075,
393 -140151432,
394 -209476638,
395 -277904834,
396 -345142998,
397 -410903207,
398 -474903865,
399 -536870912,
400 -596538995,
401 -653652607,
402 -707967178,
403 -759250125,
404 -807281846,
405 -851856663,
406 -892783698,
407 -929887697,
408 -963009773,
409 -992008094,
410 -1016758484,
411 -1037154959,
412 -1053110176,
413 -1064555814,
414 -1071442860,
415 -1073741824,
416 -1071442860,
417 -1064555814,
418 -1053110176,
419 -1037154959,
420 -1016758484,
421 -992008094,
422 -963009773,
423 -929887697,
424 -892783698,
425 -851856663,
426 -807281846,
427 -759250125,
428 -707967178,
429 -653652607,
430 -596538995,
431 -536870912,
432 -474903865,
433 -410903207,
434 -345142998,
435 -277904834,
436 -209476638,
437 -140151432,
438 -70226075,
439 0,
440 70226075,
441 140151432,
442 209476638,
443 277904834,
444 345142998,
445 410903207,
446 474903865,
447 536870912,
448 596538995,
449 653652607,
450 707967178,
451 759250125,
452 807281846,
453 851856663,
454 892783698,
455 929887697,
456 963009773,
457 992008094,
458 1016758484,
459 1037154959,
460 1053110176,
461 1064555814,
462 1071442860,
463 1073741824,
464 1071442860,
465 1064555814,
466 1053110176,
467 1037154959,
468 1016758484,
469 992008094,
470 963009773,
471 929887697,
472 892783698,
473 851856663,
474 807281846,
475 759250125,
476 707967178,
477 653652607,
478 596538995,
479 536870912,
480 474903865,
481 410903207,
482 345142998,
483 277904834,
484 209476638,
485 140151432,
486 70226075,
487 0};
488
489 #if FIXP_QTW == FIXP_SGL
490 #define HTW(x) (x)
491 #else
492 #define HTW(x) FX_DBL2FX_QTW(FX_SGL2FX_DBL((const FIXP_SGL)x))
493 #endif
494
495 static const FIXP_QTW post_twiddle_cos_8[8] = {
496 HTW(-1606), HTW(4756), HTW(-7723), HTW(10394),
497 HTW(-12665), HTW(14449), HTW(-15679), HTW(16305)};
498
499 static const FIXP_QTW post_twiddle_cos_16[16] = {
500 HTW(-804), HTW(2404), HTW(-3981), HTW(5520), HTW(-7005), HTW(8423),
501 HTW(-9760), HTW(11003), HTW(-12140), HTW(13160), HTW(-14053), HTW(14811),
502 HTW(-15426), HTW(15893), HTW(-16207), HTW(16364)};
503
504 static const FIXP_QTW post_twiddle_cos_24[24] = {
505 HTW(-536), HTW(1606), HTW(-2669), HTW(3720), HTW(-4756), HTW(5771),
506 HTW(-6762), HTW(7723), HTW(-8652), HTW(9543), HTW(-10394), HTW(11200),
507 HTW(-11958), HTW(12665), HTW(-13318), HTW(13913), HTW(-14449), HTW(14924),
508 HTW(-15334), HTW(15679), HTW(-15956), HTW(16165), HTW(-16305), HTW(16375)};
509
510 static const FIXP_QTW post_twiddle_cos_32[32] = {
511 HTW(-402), HTW(1205), HTW(-2006), HTW(2801), HTW(-3590), HTW(4370),
512 HTW(-5139), HTW(5897), HTW(-6639), HTW(7366), HTW(-8076), HTW(8765),
513 HTW(-9434), HTW(10080), HTW(-10702), HTW(11297), HTW(-11866), HTW(12406),
514 HTW(-12916), HTW(13395), HTW(-13842), HTW(14256), HTW(-14635), HTW(14978),
515 HTW(-15286), HTW(15557), HTW(-15791), HTW(15986), HTW(-16143), HTW(16261),
516 HTW(-16340), HTW(16379)};
517
518 static const FIXP_QTW post_twiddle_cos_40[40] = {
519 HTW(-322), HTW(965), HTW(-1606), HTW(2245), HTW(-2880), HTW(3511),
520 HTW(-4137), HTW(4756), HTW(-5368), HTW(5971), HTW(-6566), HTW(7150),
521 HTW(-7723), HTW(8285), HTW(-8833), HTW(9368), HTW(-9889), HTW(10394),
522 HTW(-10883), HTW(11356), HTW(-11810), HTW(12247), HTW(-12665), HTW(13063),
523 HTW(-13441), HTW(13799), HTW(-14135), HTW(14449), HTW(-14741), HTW(15011),
524 HTW(-15257), HTW(15480), HTW(-15679), HTW(15853), HTW(-16003), HTW(16129),
525 HTW(-16229), HTW(16305), HTW(-16356), HTW(16381)};
526
527 static const FIXP_QTW post_twiddle_sin_8[8] = {
528 HTW(16305), HTW(-15679), HTW(14449), HTW(-12665),
529 HTW(10394), HTW(-7723), HTW(4756), HTW(-1606)};
530
531 static const FIXP_QTW post_twiddle_sin_16[16] = {
532 HTW(16364), HTW(-16207), HTW(15893), HTW(-15426), HTW(14811), HTW(-14053),
533 HTW(13160), HTW(-12140), HTW(11003), HTW(-9760), HTW(8423), HTW(-7005),
534 HTW(5520), HTW(-3981), HTW(2404), HTW(-804)};
535
536 static const FIXP_QTW post_twiddle_sin_24[24] = {
537 HTW(16375), HTW(-16305), HTW(16165), HTW(-15956), HTW(15679), HTW(-15334),
538 HTW(14924), HTW(-14449), HTW(13913), HTW(-13318), HTW(12665), HTW(-11958),
539 HTW(11200), HTW(-10394), HTW(9543), HTW(-8652), HTW(7723), HTW(-6762),
540 HTW(5771), HTW(-4756), HTW(3720), HTW(-2669), HTW(1606), HTW(-536)};
541
542 static const FIXP_QTW post_twiddle_sin_32[32] = {
543 HTW(16379), HTW(-16340), HTW(16261), HTW(-16143), HTW(15986), HTW(-15791),
544 HTW(15557), HTW(-15286), HTW(14978), HTW(-14635), HTW(14256), HTW(-13842),
545 HTW(13395), HTW(-12916), HTW(12406), HTW(-11866), HTW(11297), HTW(-10702),
546 HTW(10080), HTW(-9434), HTW(8765), HTW(-8076), HTW(7366), HTW(-6639),
547 HTW(5897), HTW(-5139), HTW(4370), HTW(-3590), HTW(2801), HTW(-2006),
548 HTW(1205), HTW(-402)};
549
550 static const FIXP_QTW post_twiddle_sin_40[40] = {
551 HTW(16381), HTW(-16356), HTW(16305), HTW(-16229), HTW(16129), HTW(-16003),
552 HTW(15853), HTW(-15679), HTW(15480), HTW(-15257), HTW(15011), HTW(-14741),
553 HTW(14449), HTW(-14135), HTW(13799), HTW(-13441), HTW(13063), HTW(-12665),
554 HTW(12247), HTW(-11810), HTW(11356), HTW(-10883), HTW(10394), HTW(-9889),
555 HTW(9368), HTW(-8833), HTW(8285), HTW(-7723), HTW(7150), HTW(-6566),
556 HTW(5971), HTW(-5368), HTW(4756), HTW(-4137), HTW(3511), HTW(-2880),
557 HTW(2245), HTW(-1606), HTW(965), HTW(-322)};
558
559 static const FIXP_DBL preModCos[32] = {
560 -749875776, 786681536, 711263552, -821592064, -670937792, 854523392,
561 628995648, -885396032, -585538240, 914135680, 540670208, -940673088,
562 -494499680, 964944384, 447137824, -986891008, -398698816, 1006460096,
563 349299264, -1023604544, -299058240, 1038283072, 248096752, -1050460288,
564 -196537584, 1060106816, 144504928, -1067199488, -92124160, 1071721152,
565 39521456, -1073660992};
566
567 static const FIXP_DBL preModSin[32] = {
568 768510144, 730789760, -804379072, -691308864, 838310208, 650162560,
569 -870221760, -607449920, 900036928, 563273856, -927683776, -517740896,
570 953095808, 470960608, -976211712, -423045728, 996975808, 374111712,
571 -1015338112, -324276416, 1031254400, 273659904, -1044686336, -222384144,
572 1055601472, 170572640, -1063973632, -118350192, 1069782528, 65842640,
573 -1073014208, -13176464};
574
575 /* The cube root function */
576 /*****************************************************************************
577
578 functionname: invCubeRootNorm2
579 description: delivers 1/cuberoot(op) in Q1.31 format and modified exponent
580
581 *****************************************************************************/
582 #define CUBE_ROOT_BITS 7
583 #define CUBE_ROOT_VALUES (128 + 2)
584 #define CUBE_ROOT_BITS_MASK 0x7f
585 #define CUBE_ROOT_FRACT_BITS_MASK 0x007FFFFF
586 /* Inverse cube root table for operands running from 0.5 to 1.0 */
587 /* (INT) (1.0/cuberoot((op))); */
588 /* Implicit exponent is 1. */
589
590 LNK_SECTION_CONSTDATA
591 static const FIXP_DBL invCubeRootTab[CUBE_ROOT_VALUES] = {
592 (0x50a28be6), (0x506d1172), (0x503823c4), (0x5003c05a), (0x4fcfe4c0),
593 (0x4f9c8e92), (0x4f69bb7d), (0x4f37693b), (0x4f059594), (0x4ed43e5f),
594 (0x4ea36181), (0x4e72fcea), (0x4e430e98), (0x4e139495), (0x4de48cf5),
595 (0x4db5f5db), (0x4d87cd73), (0x4d5a11f2), (0x4d2cc19c), (0x4cffdabb),
596 (0x4cd35ba4), (0x4ca742b7), (0x4c7b8e5c), (0x4c503d05), (0x4c254d2a),
597 (0x4bfabd50), (0x4bd08c00), (0x4ba6b7cd), (0x4b7d3f53), (0x4b542134),
598 (0x4b2b5c18), (0x4b02eeb1), (0x4adad7b8), (0x4ab315ea), (0x4a8ba80d),
599 (0x4a648cec), (0x4a3dc35b), (0x4a174a30), (0x49f1204a), (0x49cb448d),
600 (0x49a5b5e2), (0x49807339), (0x495b7b86), (0x4936cdc2), (0x491268ec),
601 (0x48ee4c08), (0x48ca761f), (0x48a6e63e), (0x48839b76), (0x486094de),
602 (0x483dd190), (0x481b50ad), (0x47f91156), (0x47d712b3), (0x47b553f0),
603 (0x4793d43c), (0x477292c9), (0x47518ece), (0x4730c785), (0x47103c2d),
604 (0x46efec06), (0x46cfd655), (0x46affa61), (0x46905777), (0x4670ece4),
605 (0x4651b9f9), (0x4632be0b), (0x4613f871), (0x45f56885), (0x45d70da5),
606 (0x45b8e72f), (0x459af487), (0x457d3511), (0x455fa835), (0x45424d5d),
607 (0x452523f6), (0x45082b6e), (0x44eb6337), (0x44cecac5), (0x44b2618d),
608 (0x44962708), (0x447a1ab1), (0x445e3c02), (0x44428a7c), (0x4427059e),
609 (0x440bacec), (0x43f07fe9), (0x43d57e1c), (0x43baa70e), (0x439ffa48),
610 (0x43857757), (0x436b1dc8), (0x4350ed2b), (0x4336e511), (0x431d050c),
611 (0x43034cb2), (0x42e9bb98), (0x42d05156), (0x42b70d85), (0x429defc0),
612 (0x4284f7a2), (0x426c24cb), (0x425376d8), (0x423aed6a), (0x42228823),
613 (0x420a46a6), (0x41f22898), (0x41da2d9f), (0x41c25561), (0x41aa9f86),
614 (0x41930bba), (0x417b99a5), (0x416448f5), (0x414d1956), (0x41360a76),
615 (0x411f1c06), (0x41084db5), (0x40f19f35), (0x40db1039), (0x40c4a074),
616 (0x40ae4f9b), (0x40981d64), (0x40820985), (0x406c13b6), (0x40563bb1),
617 (0x4040812e), (0x402ae3e7), (0x40156399), (0x40000000), (0x3FEAB8D9)};
618 /* n.a. */
619 static const FIXP_DBL invCubeRootCorrection[3] = {0x40000000, 0x50A28BE6,
620 0x6597FA95};
621
622 /*****************************************************************************
623 * \brief calculate 1.0/cube_root(op), op contains mantissa and exponent
624 * \param op_m: (i) mantissa of operand, must not be zero (0x0000.0000) or
625 * negative
626 * \param op_e: (i) pointer to the exponent of the operand (must be initialized)
627 * and .. (o) pointer to the exponent of the result
628 * \return: (o) mantissa of the result
629 * \description:
630 * This routine calculates the cube root of the input operand, that is
631 * given with its mantissa in Q31 format (FIXP_DBL) and its exponent (INT).
632 * The resulting mantissa is returned in format Q31. The exponent (*op_e)
633 * is modified accordingly. It is not assured, that the result is fully
634 * left-aligned but assumed to have not more than 2 bits headroom. There is one
635 * macro to activate the use of this algorithm: FUNCTION_invCubeRootNorm2 By
636 * means of activating the macro INVCUBEROOTNORM2_LINEAR_INTERPOLATE_HQ, a
637 * slightly higher precision is reachable (by default, not active). For DEBUG
638 * purpose only: a FDK_ASSERT macro validates, if the input mantissa is greater
639 * zero.
640 *
641 */
642 static
643 #ifdef __arm__
644 FIXP_DBL __attribute__((always_inline))
invCubeRootNorm2(FIXP_DBL op_m,INT * op_e)645 invCubeRootNorm2(FIXP_DBL op_m, INT* op_e)
646 #else
647 FIXP_DBL
648 invCubeRootNorm2(FIXP_DBL op_m, INT* op_e)
649 #endif
650 {
651 FDK_ASSERT(op_m > FIXP_DBL(0));
652
653 /* normalize input, calculate shift value */
654 INT exponent = (INT)fNormz(op_m) - 1;
655 op_m <<= exponent;
656
657 INT index = (INT)(op_m >> (DFRACT_BITS - 1 - (CUBE_ROOT_BITS + 1))) &
658 CUBE_ROOT_BITS_MASK;
659 FIXP_DBL fract = (FIXP_DBL)(((INT)op_m & CUBE_ROOT_FRACT_BITS_MASK)
660 << (CUBE_ROOT_BITS + 1));
661 FIXP_DBL diff = invCubeRootTab[index + 1] - invCubeRootTab[index];
662 op_m = fMultAddDiv2(invCubeRootTab[index], diff << 1, fract);
663 #if defined(INVCUBEROOTNORM2_LINEAR_INTERPOLATE_HQ)
664 /* reg1 = t[i] + (t[i+1]-t[i])*fract ... already computed ... +
665 * (1-fract)fract*(t[i+2]-t[i+1])/2 */
666 if (fract != (FIXP_DBL)0) {
667 /* fract = fract * (1 - fract) */
668 fract = fMultDiv2(fract, (FIXP_DBL)((LONG)0x80000000 - (LONG)fract)) << 1;
669 diff = diff - (invCubeRootTab[index + 2] - invCubeRootTab[index + 1]);
670 op_m = fMultAddDiv2(op_m, fract, diff);
671 }
672 #endif /* INVCUBEROOTNORM2_LINEAR_INTERPOLATE_HQ */
673
674 /* calculate the output exponent = input * exp/3 = cubicroot(m)*2^(exp/3)
675 * where 2^(exp/3) = 2^k'*2 or 2^k'*2^(1/3) or 2^k'*2^(2/3) */
676 exponent = exponent - *op_e + 3;
677 INT shift_tmp =
678 ((INT)fMultDiv2((FIXP_SGL)fAbs(exponent), (FIXP_SGL)0x5556)) >> 16;
679 if (exponent < 0) {
680 shift_tmp = -shift_tmp;
681 }
682 INT rem = exponent - 3 * shift_tmp;
683 if (rem < 0) {
684 rem += 3;
685 shift_tmp--;
686 }
687
688 *op_e = shift_tmp;
689 op_m = fMultDiv2(op_m, invCubeRootCorrection[rem]) << 2;
690
691 return (op_m);
692 }
693
694 /*****************************************************************************
695
696 functionname: invFourthRootNorm2
697 description: delivers 1/FourthRoot(op) in Q1.31 format and modified
698 exponent
699
700 *****************************************************************************/
701
702 #define FOURTHROOT_BITS 7
703 #define FOURTHROOT_VALUES (128 + 2)
704 #define FOURTHROOT_BITS_MASK 0x7f
705 #define FOURTHROOT_FRACT_BITS_MASK 0x007FFFFF
706
707 LNK_SECTION_CONSTDATA
708 static const FIXP_DBL invFourthRootTab[FOURTHROOT_VALUES] = {
709 (0x4c1bf829), (0x4bf61977), (0x4bd09843), (0x4bab72ef), (0x4b86a7eb),
710 (0x4b6235ac), (0x4b3e1ab6), (0x4b1a5592), (0x4af6e4d4), (0x4ad3c718),
711 (0x4ab0fb03), (0x4a8e7f42), (0x4a6c5288), (0x4a4a7393), (0x4a28e126),
712 (0x4a079a0c), (0x49e69d16), (0x49c5e91f), (0x49a57d04), (0x498557ac),
713 (0x49657802), (0x4945dcf9), (0x49268588), (0x490770ac), (0x48e89d6a),
714 (0x48ca0ac9), (0x48abb7d6), (0x488da3a6), (0x486fcd4f), (0x485233ed),
715 (0x4834d6a3), (0x4817b496), (0x47faccf0), (0x47de1ee0), (0x47c1a999),
716 (0x47a56c51), (0x47896643), (0x476d96af), (0x4751fcd6), (0x473697ff),
717 (0x471b6773), (0x47006a81), (0x46e5a079), (0x46cb08ae), (0x46b0a279),
718 (0x46966d34), (0x467c683d), (0x466292f4), (0x4648ecbc), (0x462f74fe),
719 (0x46162b20), (0x45fd0e91), (0x45e41ebe), (0x45cb5b19), (0x45b2c315),
720 (0x459a562a), (0x458213cf), (0x4569fb81), (0x45520cbc), (0x453a4701),
721 (0x4522a9d1), (0x450b34b0), (0x44f3e726), (0x44dcc0ba), (0x44c5c0f7),
722 (0x44aee768), (0x4498339e), (0x4481a527), (0x446b3b96), (0x4454f67e),
723 (0x443ed576), (0x4428d815), (0x4412fdf3), (0x43fd46ad), (0x43e7b1de),
724 (0x43d23f23), (0x43bcee1e), (0x43a7be6f), (0x4392afb8), (0x437dc19d),
725 (0x4368f3c5), (0x435445d6), (0x433fb779), (0x432b4856), (0x4316f81a),
726 (0x4302c66f), (0x42eeb305), (0x42dabd8a), (0x42c6e5ad), (0x42b32b21),
727 (0x429f8d96), (0x428c0cc2), (0x4278a859), (0x42656010), (0x4252339e),
728 (0x423f22bc), (0x422c2d23), (0x4219528b), (0x420692b2), (0x41f3ed51),
729 (0x41e16228), (0x41cef0f2), (0x41bc9971), (0x41aa5b62), (0x41983687),
730 (0x41862aa2), (0x41743775), (0x41625cc3), (0x41509a50), (0x413eefe2),
731 (0x412d5d3e), (0x411be22b), (0x410a7e70), (0x40f931d5), (0x40e7fc23),
732 (0x40d6dd24), (0x40c5d4a2), (0x40b4e268), (0x40a40642), (0x40933ffc),
733 (0x40828f64), (0x4071f447), (0x40616e73), (0x4050fdb9), (0x4040a1e6),
734 (0x40305acc), (0x4020283c), (0x40100a08), (0x40000000), (0x3ff009f9),
735 };
736
737 static const FIXP_DBL invFourthRootCorrection[4] = {0x40000000, 0x4C1BF829,
738 0x5A82799A, 0x6BA27E65};
739
740 /* The fourth root function */
741 /*****************************************************************************
742 * \brief calculate 1.0/fourth_root(op), op contains mantissa and exponent
743 * \param op_m: (i) mantissa of operand, must not be zero (0x0000.0000) or
744 * negative
745 * \param op_e: (i) pointer to the exponent of the operand (must be initialized)
746 * and .. (o) pointer to the exponent of the result
747 * \return: (o) mantissa of the result
748 * \description:
749 * This routine calculates the cube root of the input operand, that is
750 * given with its mantissa in Q31 format (FIXP_DBL) and its exponent (INT).
751 * The resulting mantissa is returned in format Q31. The exponent (*op_e)
752 * is modified accordingly. It is not assured, that the result is fully
753 * left-aligned but assumed to have not more than 2 bits headroom. There is one
754 * macro to activate the use of this algorithm: FUNCTION_invFourthRootNorm2 By
755 * means of activating the macro INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ, a
756 * slightly higher precision is reachable (by default, not active). For DEBUG
757 * purpose only: a FDK_ASSERT macro validates, if the input mantissa is greater
758 * zero.
759 *
760 */
761
762 /* #define INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
763
764 static
765 #ifdef __arm__
766 FIXP_DBL __attribute__((always_inline))
invFourthRootNorm2(FIXP_DBL op_m,INT * op_e)767 invFourthRootNorm2(FIXP_DBL op_m, INT* op_e)
768 #else
769 FIXP_DBL
770 invFourthRootNorm2(FIXP_DBL op_m, INT* op_e)
771 #endif
772 {
773 FDK_ASSERT(op_m > FL2FXCONST_DBL(0.0));
774
775 /* normalize input, calculate shift value */
776 INT exponent = (INT)fNormz(op_m) - 1;
777 op_m <<= exponent;
778
779 INT index = (INT)(op_m >> (DFRACT_BITS - 1 - (FOURTHROOT_BITS + 1))) &
780 FOURTHROOT_BITS_MASK;
781 FIXP_DBL fract = (FIXP_DBL)(((INT)op_m & FOURTHROOT_FRACT_BITS_MASK)
782 << (FOURTHROOT_BITS + 1));
783 FIXP_DBL diff = invFourthRootTab[index + 1] - invFourthRootTab[index];
784 op_m = invFourthRootTab[index] + (fMultDiv2(diff, fract) << 1);
785
786 #if defined(INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ)
787 /* reg1 = t[i] + (t[i+1]-t[i])*fract ... already computed ... +
788 * (1-fract)fract*(t[i+2]-t[i+1])/2 */
789 if (fract != (FIXP_DBL)0) {
790 /* fract = fract * (1 - fract) */
791 fract = fMultDiv2(fract, (FIXP_DBL)((LONG)0x80000000 - (LONG)fract)) << 1;
792 diff = diff - (invFourthRootTab[index + 2] - invFourthRootTab[index + 1]);
793 op_m = fMultAddDiv2(op_m, fract, diff);
794 }
795 #endif /* INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
796
797 exponent = exponent - *op_e + 4;
798 INT rem = exponent & 0x00000003;
799 INT shift_tmp = (exponent >> 2);
800
801 *op_e = shift_tmp;
802 op_m = fMultDiv2(op_m, invFourthRootCorrection[rem]) << 2;
803
804 return (op_m);
805 }
806
807 /*****************************************************************************
808
809 functionname: inv3EigthRootNorm2
810 description: delivers 1/cubert(op) normalized to .5...1 and the shift value
811 of the OUTPUT
812
813 *****************************************************************************/
814 #define THREEIGTHROOT_BITS 7
815 #define THREEIGTHROOT_VALUES (128 + 2)
816 #define THREEIGTHROOT_BITS_MASK 0x7f
817 #define THREEIGTHROOT_FRACT_BITS_MASK 0x007FFFFF
818
819 LNK_SECTION_CONSTDATA
820 static const FIXP_DBL inv3EigthRootTab[THREEIGTHROOT_VALUES] = {
821 (0x45cae0f2), (0x45b981bf), (0x45a8492a), (0x45973691), (0x45864959),
822 (0x457580e6), (0x4564dca4), (0x45545c00), (0x4543fe6b), (0x4533c35a),
823 (0x4523aa44), (0x4513b2a4), (0x4503dbf7), (0x44f425be), (0x44e48f7b),
824 (0x44d518b6), (0x44c5c0f7), (0x44b687c8), (0x44a76cb8), (0x44986f58),
825 (0x44898f38), (0x447acbef), (0x446c2514), (0x445d9a3f), (0x444f2b0d),
826 (0x4440d71a), (0x44329e07), (0x44247f73), (0x44167b04), (0x4408905e),
827 (0x43fabf28), (0x43ed070b), (0x43df67b0), (0x43d1e0c5), (0x43c471f7),
828 (0x43b71af6), (0x43a9db71), (0x439cb31c), (0x438fa1ab), (0x4382a6d2),
829 (0x4375c248), (0x4368f3c5), (0x435c3b03), (0x434f97bc), (0x434309ac),
830 (0x43369091), (0x432a2c28), (0x431ddc30), (0x4311a06c), (0x4305789c),
831 (0x42f96483), (0x42ed63e5), (0x42e17688), (0x42d59c30), (0x42c9d4a6),
832 (0x42be1fb1), (0x42b27d1a), (0x42a6ecac), (0x429b6e2f), (0x42900172),
833 (0x4284a63f), (0x42795c64), (0x426e23b0), (0x4262fbf2), (0x4257e4f9),
834 (0x424cde96), (0x4241e89a), (0x423702d8), (0x422c2d23), (0x4221674d),
835 (0x4216b12c), (0x420c0a94), (0x4201735b), (0x41f6eb57), (0x41ec725f),
836 (0x41e2084b), (0x41d7acf3), (0x41cd6030), (0x41c321db), (0x41b8f1ce),
837 (0x41aecfe5), (0x41a4bbf8), (0x419ab5e6), (0x4190bd89), (0x4186d2bf),
838 (0x417cf565), (0x41732558), (0x41696277), (0x415faca1), (0x415603b4),
839 (0x414c6792), (0x4142d818), (0x4139552a), (0x412fdea6), (0x41267470),
840 (0x411d1668), (0x4113c472), (0x410a7e70), (0x41014445), (0x40f815d4),
841 (0x40eef302), (0x40e5dbb4), (0x40dccfcd), (0x40d3cf33), (0x40cad9cb),
842 (0x40c1ef7b), (0x40b9102a), (0x40b03bbd), (0x40a7721c), (0x409eb32e),
843 (0x4095feda), (0x408d5508), (0x4084b5a0), (0x407c208b), (0x407395b2),
844 (0x406b14fd), (0x40629e56), (0x405a31a6), (0x4051ced8), (0x404975d5),
845 (0x40412689), (0x4038e0dd), (0x4030a4bd), (0x40287215), (0x402048cf),
846 (0x401828d7), (0x4010121a), (0x40080483), (0x40000000), (0x3ff8047d),
847 };
848
849 /* The last value is rounded in order to avoid any overflow due to the values
850 * range of the root table */
851 static const FIXP_DBL inv3EigthRootCorrection[8] = {
852 0x40000000, 0x45CAE0F2, 0x4C1BF829, 0x52FF6B55,
853 0x5A82799A, 0x62B39509, 0x6BA27E65, 0x75606373};
854
855 /* The 3/8 root function */
856 /*****************************************************************************
857 * \brief calculate 1.0/3Eigth_root(op) = 1.0/(x)^(3/8), op contains mantissa
858 * and exponent
859 * \param op_m: (i) mantissa of operand, must not be zero (0x0000.0000) or
860 * negative
861 * \param op_e: (i) pointer to the exponent of the operand (must be initialized)
862 * and .. (o) pointer to the exponent of the result
863 * \return: (o) mantissa of the result
864 * \description:
865 * This routine calculates the cube root of the input operand, that is
866 * given with its mantissa in Q31 format (FIXP_DBL) and its exponent (INT).
867 * The resulting mantissa is returned in format Q31. The exponent (*op_e)
868 * is modified accordingly. It is not assured, that the result is fully
869 * left-aligned but assumed to have not more than 2 bits headroom. There is one
870 * macro to activate the use of this algorithm: FUNCTION_inv3EigthRootNorm2 By
871 * means of activating the macro INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ, a
872 * slightly higher precision is reachable (by default, not active). For DEBUG
873 * purpose only: a FDK_ASSERT macro validates, if the input mantissa is greater
874 * zero.
875 *
876 */
877
878 /* #define INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
879
880 static
881 #ifdef __arm__
882 FIXP_DBL __attribute__((always_inline))
inv3EigthRootNorm2(FIXP_DBL op_m,INT * op_e)883 inv3EigthRootNorm2(FIXP_DBL op_m, INT* op_e)
884 #else
885 FIXP_DBL
886 inv3EigthRootNorm2(FIXP_DBL op_m, INT* op_e)
887 #endif
888 {
889 FDK_ASSERT(op_m > FL2FXCONST_DBL(0.0));
890
891 /* normalize input, calculate shift op_mue */
892 INT exponent = (INT)fNormz(op_m) - 1;
893 op_m <<= exponent;
894
895 INT index = (INT)(op_m >> (DFRACT_BITS - 1 - (THREEIGTHROOT_BITS + 1))) &
896 THREEIGTHROOT_BITS_MASK;
897 FIXP_DBL fract = (FIXP_DBL)(((INT)op_m & THREEIGTHROOT_FRACT_BITS_MASK)
898 << (THREEIGTHROOT_BITS + 1));
899 FIXP_DBL diff = inv3EigthRootTab[index + 1] - inv3EigthRootTab[index];
900 op_m = inv3EigthRootTab[index] + (fMultDiv2(diff, fract) << 1);
901
902 #if defined(INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ)
903 /* op_m = t[i] + (t[i+1]-t[i])*fract ... already computed ... +
904 * (1-fract)fract*(t[i+2]-t[i+1])/2 */
905 if (fract != (FIXP_DBL)0) {
906 /* fract = fract * (1 - fract) */
907 fract = fMultDiv2(fract, (FIXP_DBL)((LONG)0x80000000 - (LONG)fract)) << 1;
908 diff = diff - (inv3EigthRootTab[index + 2] - inv3EigthRootTab[index + 1]);
909 op_m = fMultAddDiv2(op_m, fract, diff);
910 }
911 #endif /* INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
912
913 exponent = exponent - *op_e + 8;
914 INT rem = exponent & 0x00000007;
915 INT shift_tmp = (exponent >> 3);
916
917 *op_e = shift_tmp * 3;
918 op_m = fMultDiv2(op_m, inv3EigthRootCorrection[rem]) << 2;
919
920 return (fMult(op_m, fMult(op_m, op_m)));
921 }
922
923 SBR_ERROR
QmfTransposerCreate(HANDLE_HBE_TRANSPOSER * hQmfTransposer,const int frameSize,int bDisableCrossProducts,int bSbr41)924 QmfTransposerCreate(HANDLE_HBE_TRANSPOSER* hQmfTransposer, const int frameSize,
925 int bDisableCrossProducts, int bSbr41) {
926 HANDLE_HBE_TRANSPOSER hQmfTran = NULL;
927
928 int i;
929
930 if (hQmfTransposer != NULL) {
931 /* Memory allocation */
932 /*--------------------------------------------------------------------------------------------*/
933 hQmfTran =
934 (HANDLE_HBE_TRANSPOSER)FDKcalloc(1, sizeof(struct hbeTransposer));
935 if (hQmfTran == NULL) {
936 return SBRDEC_MEM_ALLOC_FAILED;
937 }
938
939 for (i = 0; i < MAX_STRETCH_HBE - 1; i++) {
940 hQmfTran->bXProducts[i] = (bDisableCrossProducts ? 0 : xProducts[i]);
941 }
942
943 hQmfTran->timeDomainWinLen = frameSize;
944 if (frameSize == 768) {
945 hQmfTran->noCols =
946 (8 * frameSize / 3) / QMF_SYNTH_CHANNELS; /* 32 for 24:64 */
947 } else {
948 hQmfTran->noCols =
949 (bSbr41 + 1) * 2 * frameSize /
950 QMF_SYNTH_CHANNELS; /* 32 for 32:64 and 64 for 16:64 -> identical to
951 sbrdec->no_cols */
952 }
953
954 hQmfTran->noChannels = frameSize / hQmfTran->noCols;
955
956 hQmfTran->qmfInBufSize = QMF_WIN_LEN;
957 hQmfTran->qmfOutBufSize = 2 * (hQmfTran->noCols / 2 + QMF_WIN_LEN - 1);
958
959 hQmfTran->inBuf_F =
960 (INT_PCM*)FDKcalloc(QMF_SYNTH_CHANNELS + 20 + 1, sizeof(INT_PCM));
961 /* buffered time signal needs to be delayed by synthesis_size; max
962 * synthesis_size = 20; */
963 if (hQmfTran->inBuf_F == NULL) {
964 QmfTransposerClose(hQmfTran);
965 return SBRDEC_MEM_ALLOC_FAILED;
966 }
967
968 hQmfTran->qmfInBufReal_F =
969 (FIXP_DBL**)FDKcalloc(hQmfTran->qmfInBufSize, sizeof(FIXP_DBL*));
970 hQmfTran->qmfInBufImag_F =
971 (FIXP_DBL**)FDKcalloc(hQmfTran->qmfInBufSize, sizeof(FIXP_DBL*));
972
973 if (hQmfTran->qmfInBufReal_F == NULL) {
974 QmfTransposerClose(hQmfTran);
975 return SBRDEC_MEM_ALLOC_FAILED;
976 }
977 if (hQmfTran->qmfInBufImag_F == NULL) {
978 QmfTransposerClose(hQmfTran);
979 return SBRDEC_MEM_ALLOC_FAILED;
980 }
981
982 for (i = 0; i < hQmfTran->qmfInBufSize; i++) {
983 hQmfTran->qmfInBufReal_F[i] = (FIXP_DBL*)FDKaalloc(
984 QMF_SYNTH_CHANNELS * sizeof(FIXP_DBL), ALIGNMENT_DEFAULT);
985 hQmfTran->qmfInBufImag_F[i] = (FIXP_DBL*)FDKaalloc(
986 QMF_SYNTH_CHANNELS * sizeof(FIXP_DBL), ALIGNMENT_DEFAULT);
987 if (hQmfTran->qmfInBufReal_F[i] == NULL) {
988 QmfTransposerClose(hQmfTran);
989 return SBRDEC_MEM_ALLOC_FAILED;
990 }
991 if (hQmfTran->qmfInBufImag_F[i] == NULL) {
992 QmfTransposerClose(hQmfTran);
993 return SBRDEC_MEM_ALLOC_FAILED;
994 }
995 }
996
997 hQmfTran->qmfHBEBufReal_F =
998 (FIXP_DBL**)FDKcalloc(HBE_MAX_OUT_SLOTS, sizeof(FIXP_DBL*));
999 hQmfTran->qmfHBEBufImag_F =
1000 (FIXP_DBL**)FDKcalloc(HBE_MAX_OUT_SLOTS, sizeof(FIXP_DBL*));
1001
1002 if (hQmfTran->qmfHBEBufReal_F == NULL) {
1003 QmfTransposerClose(hQmfTran);
1004 return SBRDEC_MEM_ALLOC_FAILED;
1005 }
1006 if (hQmfTran->qmfHBEBufImag_F == NULL) {
1007 QmfTransposerClose(hQmfTran);
1008 return SBRDEC_MEM_ALLOC_FAILED;
1009 }
1010
1011 for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1012 hQmfTran->qmfHBEBufReal_F[i] =
1013 (FIXP_DBL*)FDKcalloc(QMF_SYNTH_CHANNELS, sizeof(FIXP_DBL));
1014 hQmfTran->qmfHBEBufImag_F[i] =
1015 (FIXP_DBL*)FDKcalloc(QMF_SYNTH_CHANNELS, sizeof(FIXP_DBL));
1016 if (hQmfTran->qmfHBEBufReal_F[i] == NULL) {
1017 QmfTransposerClose(hQmfTran);
1018 return SBRDEC_MEM_ALLOC_FAILED;
1019 }
1020 if (hQmfTran->qmfHBEBufImag_F[i] == NULL) {
1021 QmfTransposerClose(hQmfTran);
1022 return SBRDEC_MEM_ALLOC_FAILED;
1023 }
1024 }
1025
1026 hQmfTran->qmfBufferCodecTempSlot_F =
1027 (FIXP_DBL*)FDKcalloc(QMF_SYNTH_CHANNELS / 2, sizeof(FIXP_DBL));
1028 if (hQmfTran->qmfBufferCodecTempSlot_F == NULL) {
1029 QmfTransposerClose(hQmfTran);
1030 return SBRDEC_MEM_ALLOC_FAILED;
1031 }
1032
1033 hQmfTran->bSbr41 = bSbr41;
1034
1035 hQmfTran->highband_exp[0] = 0;
1036 hQmfTran->highband_exp[1] = 0;
1037 hQmfTran->target_exp[0] = 0;
1038 hQmfTran->target_exp[1] = 0;
1039
1040 *hQmfTransposer = hQmfTran;
1041 }
1042
1043 return SBRDEC_OK;
1044 }
1045
QmfTransposerReInit(HANDLE_HBE_TRANSPOSER hQmfTransposer,UCHAR * FreqBandTable[2],UCHAR NSfb[2])1046 SBR_ERROR QmfTransposerReInit(HANDLE_HBE_TRANSPOSER hQmfTransposer,
1047 UCHAR* FreqBandTable[2], UCHAR NSfb[2])
1048 /* removed bSbr41 from parameterlist:
1049 don't know where to get this value from
1050 at call-side */
1051 {
1052 int L, sfb, patch, stopPatch, qmfErr;
1053
1054 if (hQmfTransposer != NULL) {
1055 const FIXP_QTW* tmp_t_cos;
1056 const FIXP_QTW* tmp_t_sin;
1057
1058 hQmfTransposer->startBand = FreqBandTable[0][0];
1059 hQmfTransposer->stopBand = FreqBandTable[0][NSfb[0]];
1060
1061 hQmfTransposer->synthSize =
1062 4 * ((hQmfTransposer->startBand + 4) / 8 + 1); /* 8, 12, 16, 20 */
1063 hQmfTransposer->kstart = startSubband2kL[hQmfTransposer->startBand];
1064
1065 /* don't know where to take this information from */
1066 /* hQmfTransposer->bSbr41 = bSbr41; */
1067
1068 if (hQmfTransposer->bSbr41) {
1069 if (hQmfTransposer->kstart + hQmfTransposer->synthSize > 16)
1070 hQmfTransposer->kstart = 16 - hQmfTransposer->synthSize;
1071 } else if (hQmfTransposer->timeDomainWinLen == 768) {
1072 if (hQmfTransposer->kstart + hQmfTransposer->synthSize > 24)
1073 hQmfTransposer->kstart = 24 - hQmfTransposer->synthSize;
1074 }
1075
1076 hQmfTransposer->synthesisQmfPreModCos_F =
1077 &preModCos[hQmfTransposer->kstart];
1078 hQmfTransposer->synthesisQmfPreModSin_F =
1079 &preModSin[hQmfTransposer->kstart];
1080
1081 L = 2 * hQmfTransposer->synthSize; /* 8, 16, 24, 32, 40 */
1082 /* Change analysis post twiddles */
1083
1084 switch (L) {
1085 case 8:
1086 tmp_t_cos = post_twiddle_cos_8;
1087 tmp_t_sin = post_twiddle_sin_8;
1088 break;
1089 case 16:
1090 tmp_t_cos = post_twiddle_cos_16;
1091 tmp_t_sin = post_twiddle_sin_16;
1092 break;
1093 case 24:
1094 tmp_t_cos = post_twiddle_cos_24;
1095 tmp_t_sin = post_twiddle_sin_24;
1096 break;
1097 case 32:
1098 tmp_t_cos = post_twiddle_cos_32;
1099 tmp_t_sin = post_twiddle_sin_32;
1100 break;
1101 case 40:
1102 tmp_t_cos = post_twiddle_cos_40;
1103 tmp_t_sin = post_twiddle_sin_40;
1104 break;
1105 default:
1106 return SBRDEC_UNSUPPORTED_CONFIG;
1107 }
1108
1109 qmfErr = qmfInitSynthesisFilterBank(
1110 &hQmfTransposer->HBESynthesisQMF, hQmfTransposer->synQmfStates,
1111 hQmfTransposer->noCols, 0, hQmfTransposer->synthSize,
1112 hQmfTransposer->synthSize, 1);
1113 if (qmfErr != 0) {
1114 return SBRDEC_UNSUPPORTED_CONFIG;
1115 }
1116
1117 qmfErr = qmfInitAnalysisFilterBank(
1118 &hQmfTransposer->HBEAnalysiscQMF, hQmfTransposer->anaQmfStates,
1119 hQmfTransposer->noCols / 2, 0, 2 * hQmfTransposer->synthSize,
1120 2 * hQmfTransposer->synthSize, 0);
1121
1122 if (qmfErr != 0) {
1123 return SBRDEC_UNSUPPORTED_CONFIG;
1124 }
1125
1126 hQmfTransposer->HBEAnalysiscQMF.t_cos = tmp_t_cos;
1127 hQmfTransposer->HBEAnalysiscQMF.t_sin = tmp_t_sin;
1128
1129 FDKmemset(hQmfTransposer->xOverQmf, 0,
1130 MAX_NUM_PATCHES * sizeof(int)); /* global */
1131 sfb = 0;
1132 if (hQmfTransposer->bSbr41) {
1133 stopPatch = MAX_NUM_PATCHES;
1134 hQmfTransposer->maxStretch = MAX_STRETCH_HBE;
1135 } else {
1136 stopPatch = MAX_STRETCH_HBE;
1137 }
1138
1139 for (patch = 1; patch <= stopPatch; patch++) {
1140 while (sfb <= NSfb[0] &&
1141 FreqBandTable[0][sfb] <= patch * hQmfTransposer->startBand)
1142 sfb++;
1143 if (sfb <= NSfb[0]) {
1144 /* If the distance is larger than three QMF bands - try aligning to high
1145 * resolution frequency bands instead. */
1146 if ((patch * hQmfTransposer->startBand - FreqBandTable[0][sfb - 1]) <=
1147 3) {
1148 hQmfTransposer->xOverQmf[patch - 1] = FreqBandTable[0][sfb - 1];
1149 } else {
1150 int sfb_tmp = 0;
1151 while (sfb_tmp <= NSfb[1] &&
1152 FreqBandTable[1][sfb_tmp] <= patch * hQmfTransposer->startBand)
1153 sfb_tmp++;
1154 hQmfTransposer->xOverQmf[patch - 1] = FreqBandTable[1][sfb_tmp - 1];
1155 }
1156 } else {
1157 hQmfTransposer->xOverQmf[patch - 1] = hQmfTransposer->stopBand;
1158 hQmfTransposer->maxStretch = fMin(patch, MAX_STRETCH_HBE);
1159 break;
1160 }
1161 }
1162
1163 hQmfTransposer->highband_exp[0] = 0;
1164 hQmfTransposer->highband_exp[1] = 0;
1165 hQmfTransposer->target_exp[0] = 0;
1166 hQmfTransposer->target_exp[1] = 0;
1167 }
1168
1169 return SBRDEC_OK;
1170 }
1171
QmfTransposerClose(HANDLE_HBE_TRANSPOSER hQmfTransposer)1172 void QmfTransposerClose(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
1173 int i;
1174
1175 if (hQmfTransposer != NULL) {
1176 if (hQmfTransposer->inBuf_F) FDKfree(hQmfTransposer->inBuf_F);
1177
1178 if (hQmfTransposer->qmfInBufReal_F) {
1179 for (i = 0; i < hQmfTransposer->qmfInBufSize; i++) {
1180 FDKafree(hQmfTransposer->qmfInBufReal_F[i]);
1181 }
1182 FDKfree(hQmfTransposer->qmfInBufReal_F);
1183 }
1184
1185 if (hQmfTransposer->qmfInBufImag_F) {
1186 for (i = 0; i < hQmfTransposer->qmfInBufSize; i++) {
1187 FDKafree(hQmfTransposer->qmfInBufImag_F[i]);
1188 }
1189 FDKfree(hQmfTransposer->qmfInBufImag_F);
1190 }
1191
1192 if (hQmfTransposer->qmfHBEBufReal_F) {
1193 for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1194 FDKfree(hQmfTransposer->qmfHBEBufReal_F[i]);
1195 }
1196 FDKfree(hQmfTransposer->qmfHBEBufReal_F);
1197 }
1198
1199 if (hQmfTransposer->qmfHBEBufImag_F) {
1200 for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1201 FDKfree(hQmfTransposer->qmfHBEBufImag_F[i]);
1202 }
1203 FDKfree(hQmfTransposer->qmfHBEBufImag_F);
1204 }
1205
1206 FDKfree(hQmfTransposer->qmfBufferCodecTempSlot_F);
1207
1208 FDKfree(hQmfTransposer);
1209 }
1210 }
1211
scaleUp(FIXP_DBL * real_m,FIXP_DBL * imag_m,INT * _e)1212 inline void scaleUp(FIXP_DBL* real_m, FIXP_DBL* imag_m, INT* _e) {
1213 INT reserve;
1214 /* shift gc_r and gc_i up if possible */
1215 reserve = CntLeadingZeros((INT(*real_m) ^ INT((*real_m >> 31))) |
1216 (INT(*imag_m) ^ INT((*imag_m >> 31)))) -
1217 1;
1218 reserve = fMax(reserve - 1,
1219 0); /* Leave one bit headroom such that (real_m^2 + imag_m^2)
1220 does not overflow later if both are 0x80000000. */
1221 reserve = fMin(reserve, *_e);
1222 FDK_ASSERT(reserve >= 0);
1223 *real_m <<= reserve;
1224 *imag_m <<= reserve;
1225 *_e -= reserve;
1226 }
1227
calculateCenterFIXP(FIXP_DBL gammaVecReal,FIXP_DBL gammaVecImag,FIXP_DBL * centerReal,FIXP_DBL * centerImag,INT * exponent,int stretch,int mult)1228 static void calculateCenterFIXP(FIXP_DBL gammaVecReal, FIXP_DBL gammaVecImag,
1229 FIXP_DBL* centerReal, FIXP_DBL* centerImag,
1230 INT* exponent, int stretch, int mult) {
1231 scaleUp(&gammaVecReal, &gammaVecImag, exponent);
1232 FIXP_DBL energy = fPow2Div2(gammaVecReal) + fPow2Div2(gammaVecImag);
1233
1234 if (energy != FL2FXCONST_DBL(0.f)) {
1235 FIXP_DBL gc_r_m, gc_i_m, factor_m = (FIXP_DBL)0;
1236 INT factor_e, gc_e;
1237 factor_e = 2 * (*exponent) + 1;
1238
1239 switch (stretch) {
1240 case 2:
1241 factor_m = invFourthRootNorm2(energy, &factor_e);
1242 break;
1243 case 3:
1244 factor_m = invCubeRootNorm2(energy, &factor_e);
1245 break;
1246 case 4:
1247 factor_m = inv3EigthRootNorm2(energy, &factor_e);
1248 break;
1249 }
1250
1251 gc_r_m = fMultDiv2(gammaVecReal,
1252 factor_m); /* exponent = HBE_SCALE + factor_e + 1 */
1253 gc_i_m = fMultDiv2(gammaVecImag,
1254 factor_m); /* exponent = HBE_SCALE + factor_e + 1*/
1255 gc_e = *exponent + factor_e + 1;
1256
1257 scaleUp(&gc_r_m, &gc_i_m, &gc_e);
1258
1259 switch (mult) {
1260 case 0:
1261 *centerReal = gc_r_m;
1262 *centerImag = gc_i_m;
1263 break;
1264 case 1:
1265 *centerReal = fPow2Div2(gc_r_m) - fPow2Div2(gc_i_m);
1266 *centerImag = fMult(gc_r_m, gc_i_m);
1267 gc_e = 2 * gc_e + 1;
1268 break;
1269 case 2:
1270 FIXP_DBL tmp_r = gc_r_m;
1271 FIXP_DBL tmp_i = gc_i_m;
1272 gc_r_m = fPow2Div2(gc_r_m) - fPow2Div2(gc_i_m);
1273 gc_i_m = fMult(tmp_r, gc_i_m);
1274 gc_e = 3 * gc_e + 1 + 1;
1275 cplxMultDiv2(¢erReal[0], ¢erImag[0], gc_r_m, gc_i_m, tmp_r,
1276 tmp_i);
1277 break;
1278 }
1279
1280 scaleUp(centerReal, centerImag, &gc_e);
1281
1282 FDK_ASSERT(gc_e >= 0);
1283 *exponent = gc_e;
1284 } else {
1285 *centerReal = energy; /* energy = 0 */
1286 *centerImag = energy; /* energy = 0 */
1287 *exponent = (INT)energy;
1288 }
1289 }
1290
getHBEScaleFactorFrame(const int bSbr41,const int maxStretch,const int pitchInBins)1291 static int getHBEScaleFactorFrame(const int bSbr41, const int maxStretch,
1292 const int pitchInBins) {
1293 if (pitchInBins >= pmin * (1 + bSbr41)) {
1294 /* crossproducts enabled */
1295 return 26;
1296 } else {
1297 return (maxStretch == 2) ? 24 : 25;
1298 }
1299 }
1300
addHighBandPart(FIXP_DBL g_r_m,FIXP_DBL g_i_m,INT g_e,FIXP_DBL mult,FIXP_DBL gammaCenterReal_m,FIXP_DBL gammaCenterImag_m,INT gammaCenter_e,INT stretch,INT scale_factor_hbe,FIXP_DBL * qmfHBEBufReal_F,FIXP_DBL * qmfHBEBufImag_F)1301 static void addHighBandPart(FIXP_DBL g_r_m, FIXP_DBL g_i_m, INT g_e,
1302 FIXP_DBL mult, FIXP_DBL gammaCenterReal_m,
1303 FIXP_DBL gammaCenterImag_m, INT gammaCenter_e,
1304 INT stretch, INT scale_factor_hbe,
1305 FIXP_DBL* qmfHBEBufReal_F,
1306 FIXP_DBL* qmfHBEBufImag_F) {
1307 if ((g_r_m | g_i_m) != FL2FXCONST_DBL(0.f)) {
1308 FIXP_DBL factor_m = (FIXP_DBL)0;
1309 INT factor_e;
1310 INT add = (stretch == 4) ? 1 : 0;
1311 INT shift = (stretch == 4) ? 1 : 2;
1312
1313 scaleUp(&g_r_m, &g_i_m, &g_e);
1314 FIXP_DBL energy = fPow2AddDiv2(fPow2Div2(g_r_m), g_i_m);
1315 factor_e = 2 * g_e + 1;
1316
1317 switch (stretch) {
1318 case 2:
1319 factor_m = invFourthRootNorm2(energy, &factor_e);
1320 break;
1321 case 3:
1322 factor_m = invCubeRootNorm2(energy, &factor_e);
1323 break;
1324 case 4:
1325 factor_m = inv3EigthRootNorm2(energy, &factor_e);
1326 break;
1327 }
1328
1329 factor_m = fMult(factor_m, mult);
1330
1331 FIXP_DBL tmp_r, tmp_i;
1332 cplxMultDiv2(&tmp_r, &tmp_i, g_r_m, g_i_m, gammaCenterReal_m,
1333 gammaCenterImag_m);
1334
1335 g_r_m = fMultDiv2(tmp_r, factor_m) << shift;
1336 g_i_m = fMultDiv2(tmp_i, factor_m) << shift;
1337 g_e = scale_factor_hbe - (g_e + factor_e + gammaCenter_e + add);
1338 fMax((INT)0, g_e);
1339 *qmfHBEBufReal_F += g_r_m >> g_e;
1340 *qmfHBEBufImag_F += g_i_m >> g_e;
1341 }
1342 }
1343
QmfTransposerApply(HANDLE_HBE_TRANSPOSER hQmfTransposer,FIXP_DBL ** qmfBufferCodecReal,FIXP_DBL ** qmfBufferCodecImag,int nColsIn,FIXP_DBL ** ppQmfBufferOutReal_F,FIXP_DBL ** ppQmfBufferOutImag_F,FIXP_DBL lpcFilterStatesReal[2+(3* (4))][(64)],FIXP_DBL lpcFilterStatesImag[2+(3* (4))][(64)],int pitchInBins,int scale_lb,int scale_hbe,int * scale_hb,int timeStep,int firstSlotOffsset,int ov_len,KEEP_STATES_SYNCED_MODE keepStatesSyncedMode)1344 void QmfTransposerApply(HANDLE_HBE_TRANSPOSER hQmfTransposer,
1345 FIXP_DBL** qmfBufferCodecReal,
1346 FIXP_DBL** qmfBufferCodecImag, int nColsIn,
1347 FIXP_DBL** ppQmfBufferOutReal_F,
1348 FIXP_DBL** ppQmfBufferOutImag_F,
1349 FIXP_DBL lpcFilterStatesReal[2 + (3 * (4))][(64)],
1350 FIXP_DBL lpcFilterStatesImag[2 + (3 * (4))][(64)],
1351 int pitchInBins, int scale_lb, int scale_hbe,
1352 int* scale_hb, int timeStep, int firstSlotOffsset,
1353 int ov_len,
1354 KEEP_STATES_SYNCED_MODE keepStatesSyncedMode) {
1355 int i, j, stretch, band, sourceband, r, s;
1356 int qmfVocoderColsIn = hQmfTransposer->noCols / 2;
1357 int bSbr41 = hQmfTransposer->bSbr41;
1358
1359 const int winLength[3] = {10, 8, 6};
1360 const int slotOffset = 6; /* hQmfTransposer->winLen-6; */
1361
1362 int qmfOffset = 2 * hQmfTransposer->kstart;
1363 int scale_border = (nColsIn == 64) ? 32 : nColsIn;
1364
1365 INT slot_stretch4[9] = {0, 0, 0, 0, 2, 4, 6, 8, 10};
1366 INT slot_stretch2[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
1367 INT slot_stretch3[10] = {0, 0, 0, 1, 3, 4, 6, 7, 9, 10};
1368 INT filt_stretch3[10] = {0, 0, 0, 1, 0, 1, 0, 1, 0, 1};
1369 INT filt_dummy[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1370 INT* pSlotStretch;
1371 INT* pFilt;
1372
1373 int offset = 0; /* where to take QmfTransposer data */
1374
1375 int signPreMod =
1376 (hQmfTransposer->synthesisQmfPreModCos_F[0] < FL2FXCONST_DBL(0.f)) ? 1
1377 : -1;
1378
1379 int scale_factor_hbe =
1380 getHBEScaleFactorFrame(bSbr41, hQmfTransposer->maxStretch, pitchInBins);
1381
1382 if (keepStatesSyncedMode != KEEP_STATES_SYNCED_OFF) {
1383 offset = hQmfTransposer->noCols - ov_len - LPC_ORDER;
1384 }
1385
1386 hQmfTransposer->highband_exp[0] = hQmfTransposer->highband_exp[1];
1387 hQmfTransposer->target_exp[0] = hQmfTransposer->target_exp[1];
1388
1389 hQmfTransposer->highband_exp[1] = scale_factor_hbe;
1390 hQmfTransposer->target_exp[1] =
1391 fixMax(hQmfTransposer->highband_exp[1], hQmfTransposer->highband_exp[0]);
1392
1393 scale_factor_hbe = hQmfTransposer->target_exp[1];
1394
1395 int shift_ov = hQmfTransposer->target_exp[0] - hQmfTransposer->target_exp[1];
1396
1397 if (shift_ov != 0) {
1398 for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1399 for (band = 0; band < QMF_SYNTH_CHANNELS; band++) {
1400 if (shift_ov >= 0) {
1401 hQmfTransposer->qmfHBEBufReal_F[i][band] <<= shift_ov;
1402 hQmfTransposer->qmfHBEBufImag_F[i][band] <<= shift_ov;
1403 } else {
1404 hQmfTransposer->qmfHBEBufReal_F[i][band] >>= (-shift_ov);
1405 hQmfTransposer->qmfHBEBufImag_F[i][band] >>= (-shift_ov);
1406 }
1407 }
1408 }
1409 }
1410
1411 if ((keepStatesSyncedMode == KEEP_STATES_SYNCED_OFF) && shift_ov != 0) {
1412 for (i = timeStep * firstSlotOffsset; i < ov_len; i++) {
1413 for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
1414 band++) {
1415 if (shift_ov >= 0) {
1416 ppQmfBufferOutReal_F[i][band] <<= shift_ov;
1417 ppQmfBufferOutImag_F[i][band] <<= shift_ov;
1418 } else {
1419 ppQmfBufferOutReal_F[i][band] >>= (-shift_ov);
1420 ppQmfBufferOutImag_F[i][band] >>= (-shift_ov);
1421 }
1422 }
1423 }
1424
1425 /* shift lpc filterstates */
1426 for (i = 0; i < timeStep * firstSlotOffsset + LPC_ORDER; i++) {
1427 for (band = 0; band < (64); band++) {
1428 if (shift_ov >= 0) {
1429 lpcFilterStatesReal[i][band] <<= shift_ov;
1430 lpcFilterStatesImag[i][band] <<= shift_ov;
1431 } else {
1432 lpcFilterStatesReal[i][band] >>= (-shift_ov);
1433 lpcFilterStatesImag[i][band] >>= (-shift_ov);
1434 }
1435 }
1436 }
1437 }
1438
1439 FIXP_DBL twid_m_new[3][2]; /* [stretch][cos/sin] */
1440 INT stepsize = 1 + !bSbr41, sine_offset = 24, mod = 96;
1441 INT mult[3] = {1, 2, 3};
1442
1443 for (s = 0; s <= MAX_STRETCH_HBE - 2; s++) {
1444 twid_m_new[s][0] = twiddle[(mult[s] * (stepsize * pitchInBins)) % mod];
1445 twid_m_new[s][1] =
1446 twiddle[((mult[s] * (stepsize * pitchInBins)) + sine_offset) % mod];
1447 }
1448
1449 /* Time-stretch */
1450 for (j = 0; j < qmfVocoderColsIn; j++) {
1451 int sign = -1, k, z, addrshift, codecTemp_e;
1452 /* update inbuf */
1453 for (i = 0; i < hQmfTransposer->synthSize; i++) {
1454 hQmfTransposer->inBuf_F[i] =
1455 hQmfTransposer->inBuf_F[i + 2 * hQmfTransposer->synthSize];
1456 }
1457
1458 /* run synthesis for two sbr slots as transposer uses
1459 half slots double bands representation */
1460 for (z = 0; z < 2; z++) {
1461 int scale_factor = ((nColsIn == 64) && ((2 * j + z) < scale_border))
1462 ? scale_lb
1463 : scale_hbe;
1464 codecTemp_e = scale_factor - 1; /* -2 for Div2 and cos/sin scale of 1 */
1465
1466 for (k = 0; k < hQmfTransposer->synthSize; k++) {
1467 int ki = hQmfTransposer->kstart + k;
1468 hQmfTransposer->qmfBufferCodecTempSlot_F[k] =
1469 fMultDiv2(signPreMod * hQmfTransposer->synthesisQmfPreModCos_F[k],
1470 qmfBufferCodecReal[2 * j + z][ki]);
1471 hQmfTransposer->qmfBufferCodecTempSlot_F[k] +=
1472 fMultDiv2(signPreMod * hQmfTransposer->synthesisQmfPreModSin_F[k],
1473 qmfBufferCodecImag[2 * j + z][ki]);
1474 }
1475
1476 C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1477
1478 qmfSynthesisFilteringSlot(
1479 &hQmfTransposer->HBESynthesisQMF,
1480 hQmfTransposer->qmfBufferCodecTempSlot_F, NULL, 0,
1481 -7 - hQmfTransposer->HBESynthesisQMF.filterScale - codecTemp_e + 1,
1482 hQmfTransposer->inBuf_F + hQmfTransposer->synthSize * (z + 1), 1,
1483 pWorkBuffer);
1484
1485 C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1486 }
1487
1488 C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1489
1490 qmfAnalysisFilteringSlot(&hQmfTransposer->HBEAnalysiscQMF,
1491 hQmfTransposer->qmfInBufReal_F[QMF_WIN_LEN - 1],
1492 hQmfTransposer->qmfInBufImag_F[QMF_WIN_LEN - 1],
1493 hQmfTransposer->inBuf_F + 1, 1, pWorkBuffer);
1494
1495 C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1496
1497 if ((keepStatesSyncedMode == KEEP_STATES_SYNCED_NORMAL) &&
1498 j <= qmfVocoderColsIn - ((LPC_ORDER + ov_len + QMF_WIN_LEN - 1) >> 1)) {
1499 /* update in buffer */
1500 for (i = 0; i < QMF_WIN_LEN - 1; i++) {
1501 FDKmemcpy(
1502 hQmfTransposer->qmfInBufReal_F[i],
1503 hQmfTransposer->qmfInBufReal_F[i + 1],
1504 sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
1505 FDKmemcpy(
1506 hQmfTransposer->qmfInBufImag_F[i],
1507 hQmfTransposer->qmfInBufImag_F[i + 1],
1508 sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
1509 }
1510 continue;
1511 }
1512
1513 for (stretch = 2; stretch <= hQmfTransposer->maxStretch; stretch++) {
1514 int start = slotOffset - winLength[stretch - 2] / 2;
1515 int stop = slotOffset + winLength[stretch - 2] / 2;
1516
1517 FIXP_DBL factor = FL2FXCONST_DBL(1.f / 3.f);
1518
1519 for (band = hQmfTransposer->xOverQmf[stretch - 2];
1520 band < hQmfTransposer->xOverQmf[stretch - 1]; band++) {
1521 FIXP_DBL gammaCenterReal_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0},
1522 gammaCenterImag_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0};
1523 INT gammaCenter_e[2] = {0, 0};
1524
1525 FIXP_DBL gammaVecReal_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0},
1526 gammaVecImag_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0};
1527 INT gammaVec_e[2] = {0, 0};
1528
1529 FIXP_DBL wingain = (FIXP_DBL)0;
1530
1531 gammaCenter_e[0] =
1532 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1533 gammaCenter_e[1] =
1534 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1535
1536 /* interpolation filters for 3rd order */
1537 sourceband = 2 * band / stretch - qmfOffset;
1538 FDK_ASSERT(sourceband >= 0);
1539
1540 /* maximum gammaCenter_e == 20 */
1541 calculateCenterFIXP(
1542 hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband],
1543 hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband],
1544 &gammaCenterReal_m[0], &gammaCenterImag_m[0], &gammaCenter_e[0],
1545 stretch, stretch - 2);
1546
1547 if (stretch == 4) {
1548 r = band - 2 * (band / 2);
1549 sourceband += (r == 0) ? -1 : 1;
1550 pSlotStretch = slot_stretch4;
1551 factor = FL2FXCONST_DBL(2.f / 3.f);
1552 pFilt = filt_dummy;
1553 } else if (stretch == 2) {
1554 r = 0;
1555 sourceband = 2 * band / stretch - qmfOffset;
1556 pSlotStretch = slot_stretch2;
1557 factor = FL2FXCONST_DBL(1.f / 3.f);
1558 pFilt = filt_dummy;
1559 } else {
1560 r = 2 * band - 3 * (2 * band / 3);
1561 sourceband = 2 * band / stretch - qmfOffset;
1562 pSlotStretch = slot_stretch3;
1563 factor = FL2FXCONST_DBL(1.4142f / 3.0f);
1564 pFilt = filt_stretch3;
1565 }
1566
1567 if (r == 2) {
1568 calculateCenterFIXP(
1569 hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband + 1],
1570 hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband + 1],
1571 &gammaCenterReal_m[1], &gammaCenterImag_m[1], &gammaCenter_e[1],
1572 stretch, stretch - 2);
1573
1574 factor = FL2FXCONST_DBL(1.4142f / 6.0f);
1575 }
1576
1577 if (r == 2) {
1578 for (k = start; k < stop; k++) {
1579 gammaVecReal_m[0] =
1580 hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband];
1581 gammaVecReal_m[1] =
1582 hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband + 1];
1583 gammaVecImag_m[0] =
1584 hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband];
1585 gammaVecImag_m[1] =
1586 hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband + 1];
1587 gammaVec_e[0] = gammaVec_e[1] =
1588 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1589
1590 if (pFilt[k] == 1) {
1591 FIXP_DBL tmpRealF = gammaVecReal_m[0], tmpImagF;
1592 gammaVecReal_m[0] =
1593 (fMult(gammaVecReal_m[0], hintReal_F[sourceband % 4][1]) -
1594 fMult(gammaVecImag_m[0],
1595 hintReal_F[(sourceband + 3) % 4][1])) >>
1596 1; /* sum should be <= 1 because of sin/cos multiplication */
1597 gammaVecImag_m[0] =
1598 (fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][1]) +
1599 fMult(gammaVecImag_m[0], hintReal_F[sourceband % 4][1])) >>
1600 1; /* sum should be <= 1 because of sin/cos multiplication */
1601
1602 tmpRealF = hQmfTransposer
1603 ->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband];
1604 tmpImagF = hQmfTransposer
1605 ->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband];
1606
1607 gammaVecReal_m[0] +=
1608 (fMult(tmpRealF, hintReal_F[sourceband % 4][1]) -
1609 fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][1])) >>
1610 1; /* sum should be <= 1 because of sin/cos multiplication */
1611 gammaVecImag_m[0] +=
1612 (fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][1]) +
1613 fMult(tmpImagF, hintReal_F[sourceband % 4][1])) >>
1614 1; /* sum should be <= 1 because of sin/cos multiplication */
1615 gammaVec_e[0]++;
1616
1617 tmpRealF = gammaVecReal_m[1];
1618
1619 gammaVecReal_m[1] =
1620 (fMult(gammaVecReal_m[1], hintReal_F[sourceband % 4][2]) -
1621 fMult(gammaVecImag_m[1],
1622 hintReal_F[(sourceband + 3) % 4][2])) >>
1623 1;
1624 gammaVecImag_m[1] =
1625 (fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][2]) +
1626 fMult(gammaVecImag_m[1], hintReal_F[sourceband % 4][2])) >>
1627 1;
1628
1629 tmpRealF =
1630 hQmfTransposer
1631 ->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband + 1];
1632 tmpImagF =
1633 hQmfTransposer
1634 ->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband + 1];
1635
1636 gammaVecReal_m[1] +=
1637 (fMult(tmpRealF, hintReal_F[sourceband % 4][2]) -
1638 fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][2])) >>
1639 1;
1640 gammaVecImag_m[1] +=
1641 (fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][2]) +
1642 fMult(tmpImagF, hintReal_F[sourceband % 4][2])) >>
1643 1;
1644 gammaVec_e[1]++;
1645 }
1646
1647 addHighBandPart(gammaVecReal_m[1], gammaVecImag_m[1], gammaVec_e[1],
1648 factor, gammaCenterReal_m[0], gammaCenterImag_m[0],
1649 gammaCenter_e[0], stretch, scale_factor_hbe,
1650 &hQmfTransposer->qmfHBEBufReal_F[k][band],
1651 &hQmfTransposer->qmfHBEBufImag_F[k][band]);
1652
1653 addHighBandPart(gammaVecReal_m[0], gammaVecImag_m[0], gammaVec_e[0],
1654 factor, gammaCenterReal_m[1], gammaCenterImag_m[1],
1655 gammaCenter_e[1], stretch, scale_factor_hbe,
1656 &hQmfTransposer->qmfHBEBufReal_F[k][band],
1657 &hQmfTransposer->qmfHBEBufImag_F[k][band]);
1658 }
1659 } else {
1660 for (k = start; k < stop; k++) {
1661 gammaVecReal_m[0] =
1662 hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband];
1663 gammaVecImag_m[0] =
1664 hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband];
1665 gammaVec_e[0] =
1666 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1667
1668 if (pFilt[k] == 1) {
1669 FIXP_DBL tmpRealF = gammaVecReal_m[0], tmpImagF;
1670 gammaVecReal_m[0] =
1671 (fMult(gammaVecReal_m[0], hintReal_F[sourceband % 4][1]) -
1672 fMult(gammaVecImag_m[0],
1673 hintReal_F[(sourceband + 3) % 4][1])) >>
1674 1; /* sum should be <= 1 because of sin/cos multiplication */
1675 gammaVecImag_m[0] =
1676 (fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][1]) +
1677 fMult(gammaVecImag_m[0], hintReal_F[sourceband % 4][1])) >>
1678 1; /* sum should be <= 1 because of sin/cos multiplication */
1679
1680 tmpRealF = hQmfTransposer
1681 ->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband];
1682 tmpImagF = hQmfTransposer
1683 ->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband];
1684
1685 gammaVecReal_m[0] +=
1686 (fMult(tmpRealF, hintReal_F[sourceband % 4][1]) -
1687 fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][1])) >>
1688 1; /* sum should be <= 1 because of sin/cos multiplication */
1689 gammaVecImag_m[0] +=
1690 (fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][1]) +
1691 fMult(tmpImagF, hintReal_F[sourceband % 4][1])) >>
1692 1; /* sum should be <= 1 because of sin/cos multiplication */
1693 gammaVec_e[0]++;
1694 }
1695
1696 addHighBandPart(gammaVecReal_m[0], gammaVecImag_m[0], gammaVec_e[0],
1697 factor, gammaCenterReal_m[0], gammaCenterImag_m[0],
1698 gammaCenter_e[0], stretch, scale_factor_hbe,
1699 &hQmfTransposer->qmfHBEBufReal_F[k][band],
1700 &hQmfTransposer->qmfHBEBufImag_F[k][band]);
1701 }
1702 }
1703
1704 /* pitchInBins is given with the resolution of a 768 bins FFT and we
1705 * need 64 QMF units so factor 768/64 = 12 */
1706 if (pitchInBins >= pmin * (1 + bSbr41)) {
1707 int tr, ti1, ti2, mTr = 0, ts1 = 0, ts2 = 0, mVal_e = 0, temp_e = 0;
1708 int sqmag0_e =
1709 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1710
1711 FIXP_DBL mVal_F = FL2FXCONST_DBL(0.f), sqmag0_F, sqmag1_F, sqmag2_F,
1712 temp_F, f1_F; /* all equal exponent */
1713 sign = -1;
1714
1715 sourceband = 2 * band / stretch - qmfOffset; /* consistent with the
1716 already computed for
1717 stretch = 3,4. */
1718 FDK_ASSERT(sourceband >= 0);
1719
1720 FIXP_DBL sqmag0R_F =
1721 hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband];
1722 FIXP_DBL sqmag0I_F =
1723 hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband];
1724 scaleUp(&sqmag0R_F, &sqmag0I_F, &sqmag0_e);
1725
1726 sqmag0_F = fPow2Div2(sqmag0R_F);
1727 sqmag0_F += fPow2Div2(sqmag0I_F);
1728 sqmag0_e = 2 * sqmag0_e + 1;
1729
1730 for (tr = 1; tr < stretch; tr++) {
1731 int sqmag1_e =
1732 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1733 int sqmag2_e =
1734 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1735
1736 FIXP_DBL tmp_band = band_F[band];
1737 FIXP_DBL tr_p =
1738 fMult(p_F[pitchInBins] >> bSbr41, tr_str[tr - 1]); /* scale 7 */
1739 f1_F =
1740 fMult(tmp_band - tr_p, stretchfac[stretch - 2]); /* scale 7 */
1741 ti1 = (INT)(f1_F >> (DFRACT_BITS - 1 - 7)) - qmfOffset;
1742 ti2 = (INT)(((f1_F) + ((p_F[pitchInBins] >> bSbr41) >> 2)) >>
1743 (DFRACT_BITS - 1 - 7)) -
1744 qmfOffset;
1745
1746 if (ti1 >= 0 && ti2 < 2 * hQmfTransposer->synthSize) {
1747 FIXP_DBL sqmag1R_F =
1748 hQmfTransposer->qmfInBufReal_F[slotOffset][ti1];
1749 FIXP_DBL sqmag1I_F =
1750 hQmfTransposer->qmfInBufImag_F[slotOffset][ti1];
1751 scaleUp(&sqmag1R_F, &sqmag1I_F, &sqmag1_e);
1752 sqmag1_F = fPow2Div2(sqmag1R_F);
1753 sqmag1_F += fPow2Div2(sqmag1I_F);
1754 sqmag1_e = 2 * sqmag1_e + 1;
1755
1756 FIXP_DBL sqmag2R_F =
1757 hQmfTransposer->qmfInBufReal_F[slotOffset][ti2];
1758 FIXP_DBL sqmag2I_F =
1759 hQmfTransposer->qmfInBufImag_F[slotOffset][ti2];
1760 scaleUp(&sqmag2R_F, &sqmag2I_F, &sqmag2_e);
1761 sqmag2_F = fPow2Div2(sqmag2R_F);
1762 sqmag2_F += fPow2Div2(sqmag2I_F);
1763 sqmag2_e = 2 * sqmag2_e + 1;
1764
1765 int shift1 = fMin(fMax(sqmag1_e, sqmag2_e) - sqmag1_e, 31);
1766 int shift2 = fMin(fMax(sqmag1_e, sqmag2_e) - sqmag2_e, 31);
1767
1768 temp_F = fMin((sqmag1_F >> shift1), (sqmag2_F >> shift2));
1769 temp_e = fMax(sqmag1_e, sqmag2_e);
1770
1771 int shift3 = fMin(fMax(temp_e, mVal_e) - temp_e, 31);
1772 int shift4 = fMin(fMax(temp_e, mVal_e) - mVal_e, 31);
1773
1774 if ((temp_F >> shift3) > (mVal_F >> shift4)) {
1775 mVal_F = temp_F;
1776 mVal_e = temp_e; /* equals sqmag2_e + shift2 */
1777 mTr = tr;
1778 ts1 = ti1;
1779 ts2 = ti2;
1780 }
1781 }
1782 }
1783
1784 int shift1 = fMin(fMax(sqmag0_e, mVal_e) - sqmag0_e, 31);
1785 int shift2 = fMin(fMax(sqmag0_e, mVal_e) - mVal_e, 31);
1786
1787 if ((mVal_F >> shift2) > (sqmag0_F >> shift1) && ts1 >= 0 &&
1788 ts2 < 2 * hQmfTransposer->synthSize) {
1789 INT gammaOut_e[2];
1790 FIXP_DBL gammaOutReal_m[2], gammaOutImag_m[2];
1791 FIXP_DBL tmpReal_m = (FIXP_DBL)0, tmpImag_m = (FIXP_DBL)0;
1792
1793 int Tcenter, Tvec;
1794
1795 Tcenter = stretch - mTr; /* default phase power parameters */
1796 Tvec = mTr;
1797 switch (stretch) /* 2 tap block creation design depends on stretch
1798 order */
1799 {
1800 case 2:
1801 wingain =
1802 FL2FXCONST_DBL(5.f / 12.f); /* sum of taps divided by two */
1803
1804 if (hQmfTransposer->bXProducts[0]) {
1805 gammaCenterReal_m[0] =
1806 hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1807 gammaCenterImag_m[0] =
1808 hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1809
1810 for (k = 0; k < 2; k++) {
1811 gammaVecReal_m[k] =
1812 hQmfTransposer->qmfInBufReal_F[slotOffset - 1 + k][ts2];
1813 gammaVecImag_m[k] =
1814 hQmfTransposer->qmfInBufImag_F[slotOffset - 1 + k][ts2];
1815 }
1816
1817 gammaCenter_e[0] = SCALE2EXP(
1818 -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1819 gammaVec_e[0] = gammaVec_e[1] = SCALE2EXP(
1820 -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1821 }
1822 break;
1823
1824 case 4:
1825 wingain =
1826 FL2FXCONST_DBL(6.f / 12.f); /* sum of taps divided by two */
1827 if (hQmfTransposer->bXProducts[2]) {
1828 if (mTr == 1) {
1829 gammaCenterReal_m[0] =
1830 hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1831 gammaCenterImag_m[0] =
1832 hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1833
1834 for (k = 0; k < 2; k++) {
1835 gammaVecReal_m[k] =
1836 hQmfTransposer
1837 ->qmfInBufReal_F[slotOffset + 2 * (k - 1)][ts2];
1838 gammaVecImag_m[k] =
1839 hQmfTransposer
1840 ->qmfInBufImag_F[slotOffset + 2 * (k - 1)][ts2];
1841 }
1842 } else if (mTr == 2) {
1843 gammaCenterReal_m[0] =
1844 hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1845 gammaCenterImag_m[0] =
1846 hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1847
1848 for (k = 0; k < 2; k++) {
1849 gammaVecReal_m[k] =
1850 hQmfTransposer
1851 ->qmfInBufReal_F[slotOffset + (k - 1)][ts2];
1852 gammaVecImag_m[k] =
1853 hQmfTransposer
1854 ->qmfInBufImag_F[slotOffset + (k - 1)][ts2];
1855 }
1856 } else /* (mTr == 3) */
1857 {
1858 sign = 1;
1859 Tcenter = mTr; /* opposite phase power parameters as ts2 is
1860 center */
1861 Tvec = stretch - mTr;
1862
1863 gammaCenterReal_m[0] =
1864 hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
1865 gammaCenterImag_m[0] =
1866 hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
1867
1868 for (k = 0; k < 2; k++) {
1869 gammaVecReal_m[k] =
1870 hQmfTransposer
1871 ->qmfInBufReal_F[slotOffset + 2 * (k - 1)][ts1];
1872 gammaVecImag_m[k] =
1873 hQmfTransposer
1874 ->qmfInBufImag_F[slotOffset + 2 * (k - 1)][ts1];
1875 }
1876 }
1877
1878 gammaCenter_e[0] = SCALE2EXP(
1879 -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1880 gammaVec_e[0] = gammaVec_e[1] = SCALE2EXP(
1881 -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1882 }
1883 break;
1884
1885 case 3:
1886 wingain = FL2FXCONST_DBL(5.6568f /
1887 12.f); /* sum of taps divided by two */
1888
1889 if (hQmfTransposer->bXProducts[1]) {
1890 FIXP_DBL tmpReal_F, tmpImag_F;
1891 if (mTr == 1) {
1892 gammaCenterReal_m[0] =
1893 hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1894 gammaCenterImag_m[0] =
1895 hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1896 gammaVecReal_m[1] =
1897 hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
1898 gammaVecImag_m[1] =
1899 hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
1900
1901 addrshift = -2;
1902 tmpReal_F =
1903 hQmfTransposer
1904 ->qmfInBufReal_F[addrshift + slotOffset][ts2];
1905 tmpImag_F =
1906 hQmfTransposer
1907 ->qmfInBufImag_F[addrshift + slotOffset][ts2];
1908
1909 gammaVecReal_m[0] =
1910 (fMult(factors[ts2 % 4], tmpReal_F) -
1911 fMult(factors[(ts2 + 3) % 4], tmpImag_F)) >>
1912 1;
1913 gammaVecImag_m[0] =
1914 (fMult(factors[(ts2 + 3) % 4], tmpReal_F) +
1915 fMult(factors[ts2 % 4], tmpImag_F)) >>
1916 1;
1917
1918 tmpReal_F =
1919 hQmfTransposer
1920 ->qmfInBufReal_F[addrshift + 1 + slotOffset][ts2];
1921 tmpImag_F =
1922 hQmfTransposer
1923 ->qmfInBufImag_F[addrshift + 1 + slotOffset][ts2];
1924
1925 gammaVecReal_m[0] +=
1926 (fMult(factors[ts2 % 4], tmpReal_F) -
1927 fMult(factors[(ts2 + 1) % 4], tmpImag_F)) >>
1928 1;
1929 gammaVecImag_m[0] +=
1930 (fMult(factors[(ts2 + 1) % 4], tmpReal_F) +
1931 fMult(factors[ts2 % 4], tmpImag_F)) >>
1932 1;
1933
1934 } else /* (mTr == 2) */
1935 {
1936 sign = 1;
1937 Tcenter = mTr; /* opposite phase power parameters as ts2 is
1938 center */
1939 Tvec = stretch - mTr;
1940
1941 gammaCenterReal_m[0] =
1942 hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
1943 gammaCenterImag_m[0] =
1944 hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
1945 gammaVecReal_m[1] =
1946 hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1947 gammaVecImag_m[1] =
1948 hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1949
1950 addrshift = -2;
1951 tmpReal_F =
1952 hQmfTransposer
1953 ->qmfInBufReal_F[addrshift + slotOffset][ts1];
1954 tmpImag_F =
1955 hQmfTransposer
1956 ->qmfInBufImag_F[addrshift + slotOffset][ts1];
1957
1958 gammaVecReal_m[0] =
1959 (fMult(factors[ts1 % 4], tmpReal_F) -
1960 fMult(factors[(ts1 + 3) % 4], tmpImag_F)) >>
1961 1;
1962 gammaVecImag_m[0] =
1963 (fMult(factors[(ts1 + 3) % 4], tmpReal_F) +
1964 fMult(factors[ts1 % 4], tmpImag_F)) >>
1965 1;
1966
1967 tmpReal_F =
1968 hQmfTransposer
1969 ->qmfInBufReal_F[addrshift + 1 + slotOffset][ts1];
1970 tmpImag_F =
1971 hQmfTransposer
1972 ->qmfInBufImag_F[addrshift + 1 + slotOffset][ts1];
1973
1974 gammaVecReal_m[0] +=
1975 (fMult(factors[ts1 % 4], tmpReal_F) -
1976 fMult(factors[(ts1 + 1) % 4], tmpImag_F)) >>
1977 1;
1978 gammaVecImag_m[0] +=
1979 (fMult(factors[(ts1 + 1) % 4], tmpReal_F) +
1980 fMult(factors[ts1 % 4], tmpImag_F)) >>
1981 1;
1982 }
1983
1984 gammaCenter_e[0] = gammaVec_e[1] = SCALE2EXP(
1985 -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1986 gammaVec_e[0] =
1987 SCALE2EXP(
1988 -hQmfTransposer->HBEAnalysiscQMF.outScalefactor) +
1989 1;
1990 }
1991 break;
1992 default:
1993 FDK_ASSERT(0);
1994 break;
1995 } /* stretch cases */
1996
1997 /* parameter controlled phase modification parts */
1998 /* maximum *_e == 20 */
1999 calculateCenterFIXP(gammaCenterReal_m[0], gammaCenterImag_m[0],
2000 &gammaCenterReal_m[0], &gammaCenterImag_m[0],
2001 &gammaCenter_e[0], stretch, Tcenter - 1);
2002 calculateCenterFIXP(gammaVecReal_m[0], gammaVecImag_m[0],
2003 &gammaVecReal_m[0], &gammaVecImag_m[0],
2004 &gammaVec_e[0], stretch, Tvec - 1);
2005 calculateCenterFIXP(gammaVecReal_m[1], gammaVecImag_m[1],
2006 &gammaVecReal_m[1], &gammaVecImag_m[1],
2007 &gammaVec_e[1], stretch, Tvec - 1);
2008
2009 /* Final multiplication of prepared parts */
2010 for (k = 0; k < 2; k++) {
2011 gammaOutReal_m[k] =
2012 fMultDiv2(gammaVecReal_m[k], gammaCenterReal_m[0]) -
2013 fMultDiv2(gammaVecImag_m[k], gammaCenterImag_m[0]);
2014 gammaOutImag_m[k] =
2015 fMultDiv2(gammaVecReal_m[k], gammaCenterImag_m[0]) +
2016 fMultDiv2(gammaVecImag_m[k], gammaCenterReal_m[0]);
2017 gammaOut_e[k] = gammaCenter_e[0] + gammaVec_e[k] + 1;
2018 }
2019
2020 scaleUp(&gammaOutReal_m[0], &gammaOutImag_m[0], &gammaOut_e[0]);
2021 scaleUp(&gammaOutReal_m[1], &gammaOutImag_m[1], &gammaOut_e[1]);
2022 FDK_ASSERT(gammaOut_e[0] >= 0);
2023 FDK_ASSERT(gammaOut_e[0] < 32);
2024
2025 tmpReal_m = gammaOutReal_m[0];
2026 tmpImag_m = gammaOutImag_m[0];
2027
2028 INT modstretch4 = ((stretch == 4) && (mTr == 2));
2029
2030 FIXP_DBL cos_twid = twid_m_new[stretch - 2 - modstretch4][0];
2031 FIXP_DBL sin_twid = sign * twid_m_new[stretch - 2 - modstretch4][1];
2032
2033 gammaOutReal_m[0] =
2034 fMult(tmpReal_m, cos_twid) -
2035 fMult(tmpImag_m, sin_twid); /* sum should be <= 1 because of
2036 sin/cos multiplication */
2037 gammaOutImag_m[0] =
2038 fMult(tmpImag_m, cos_twid) +
2039 fMult(tmpReal_m, sin_twid); /* sum should be <= 1 because of
2040 sin/cos multiplication */
2041
2042 /* wingain */
2043 for (k = 0; k < 2; k++) {
2044 gammaOutReal_m[k] = (fMult(gammaOutReal_m[k], wingain) << 1);
2045 gammaOutImag_m[k] = (fMult(gammaOutImag_m[k], wingain) << 1);
2046 }
2047
2048 gammaOutReal_m[1] >>= 1;
2049 gammaOutImag_m[1] >>= 1;
2050 gammaOut_e[0] += 2;
2051 gammaOut_e[1] += 2;
2052
2053 /* OLA including window scaling by wingain/3 */
2054 for (k = 0; k < 2; k++) /* need k=1 to correspond to
2055 grainModImag[slotOffset] -> out to
2056 j*2+(slotOffset-offset) */
2057 {
2058 hQmfTransposer->qmfHBEBufReal_F[(k + slotOffset - 1)][band] +=
2059 gammaOutReal_m[k] >> (scale_factor_hbe - gammaOut_e[k]);
2060 hQmfTransposer->qmfHBEBufImag_F[(k + slotOffset - 1)][band] +=
2061 gammaOutImag_m[k] >> (scale_factor_hbe - gammaOut_e[k]);
2062 }
2063 } /* mVal > qThrQMF * qThrQMF * sqmag0 && ts1 > 0 && ts2 < 64 */
2064 } /* p >= pmin */
2065 } /* for band */
2066 } /* for stretch */
2067
2068 for (i = 0; i < QMF_WIN_LEN - 1; i++) {
2069 FDKmemcpy(hQmfTransposer->qmfInBufReal_F[i],
2070 hQmfTransposer->qmfInBufReal_F[i + 1],
2071 sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
2072 FDKmemcpy(hQmfTransposer->qmfInBufImag_F[i],
2073 hQmfTransposer->qmfInBufImag_F[i + 1],
2074 sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
2075 }
2076
2077 if (keepStatesSyncedMode != KEEP_STATES_SYNCED_NOOUT) {
2078 if (2 * j >= offset) {
2079 /* copy first two slots of internal buffer to output */
2080 if (keepStatesSyncedMode == KEEP_STATES_SYNCED_OUTDIFF) {
2081 for (i = 0; i < 2; i++) {
2082 FDKmemcpy(&ppQmfBufferOutReal_F[2 * j - offset + i]
2083 [hQmfTransposer->xOverQmf[0]],
2084 &hQmfTransposer
2085 ->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
2086 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2087 sizeof(FIXP_DBL));
2088 FDKmemcpy(&ppQmfBufferOutImag_F[2 * j - offset + i]
2089 [hQmfTransposer->xOverQmf[0]],
2090 &hQmfTransposer
2091 ->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
2092 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2093 sizeof(FIXP_DBL));
2094 }
2095 } else {
2096 for (i = 0; i < 2; i++) {
2097 FDKmemcpy(&ppQmfBufferOutReal_F[2 * j + i + ov_len]
2098 [hQmfTransposer->xOverQmf[0]],
2099 &hQmfTransposer
2100 ->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
2101 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2102 sizeof(FIXP_DBL));
2103 FDKmemcpy(&ppQmfBufferOutImag_F[2 * j + i + ov_len]
2104 [hQmfTransposer->xOverQmf[0]],
2105 &hQmfTransposer
2106 ->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
2107 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2108 sizeof(FIXP_DBL));
2109 }
2110 }
2111 }
2112 }
2113
2114 /* move slots up */
2115 for (i = 0; i < HBE_MAX_OUT_SLOTS - 2; i++) {
2116 FDKmemcpy(
2117 &hQmfTransposer->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
2118 &hQmfTransposer->qmfHBEBufReal_F[i + 2][hQmfTransposer->xOverQmf[0]],
2119 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2120 sizeof(FIXP_DBL));
2121 FDKmemcpy(
2122 &hQmfTransposer->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
2123 &hQmfTransposer->qmfHBEBufImag_F[i + 2][hQmfTransposer->xOverQmf[0]],
2124 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2125 sizeof(FIXP_DBL));
2126 }
2127
2128 /* finally set last two slot to zero */
2129 for (i = 0; i < 2; i++) {
2130 FDKmemset(&hQmfTransposer->qmfHBEBufReal_F[HBE_MAX_OUT_SLOTS - 1 - i]
2131 [hQmfTransposer->xOverQmf[0]],
2132 0,
2133 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2134 sizeof(FIXP_DBL));
2135 FDKmemset(&hQmfTransposer->qmfHBEBufImag_F[HBE_MAX_OUT_SLOTS - 1 - i]
2136 [hQmfTransposer->xOverQmf[0]],
2137 0,
2138 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2139 sizeof(FIXP_DBL));
2140 }
2141 } /* qmfVocoderColsIn */
2142
2143 if (keepStatesSyncedMode != KEEP_STATES_SYNCED_NOOUT) {
2144 if (keepStatesSyncedMode == KEEP_STATES_SYNCED_OUTDIFF) {
2145 for (i = 0; i < ov_len + LPC_ORDER; i++) {
2146 for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
2147 band++) {
2148 FIXP_DBL tmpR = ppQmfBufferOutReal_F[i][band];
2149 FIXP_DBL tmpI = ppQmfBufferOutImag_F[i][band];
2150
2151 ppQmfBufferOutReal_F[i][band] =
2152 fMult(tmpR, cos_F[band]) -
2153 fMult(tmpI, (-cos_F[64 - band - 1])); /* sum should be <= 1
2154 because of sin/cos
2155 multiplication */
2156 ppQmfBufferOutImag_F[i][band] =
2157 fMult(tmpR, (-cos_F[64 - band - 1])) +
2158 fMult(tmpI, cos_F[band]); /* sum should by <= 1 because of sin/cos
2159 multiplication */
2160 }
2161 }
2162 } else {
2163 for (i = offset; i < hQmfTransposer->noCols; i++) {
2164 for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
2165 band++) {
2166 FIXP_DBL tmpR = ppQmfBufferOutReal_F[i + ov_len][band];
2167 FIXP_DBL tmpI = ppQmfBufferOutImag_F[i + ov_len][band];
2168
2169 ppQmfBufferOutReal_F[i + ov_len][band] =
2170 fMult(tmpR, cos_F[band]) -
2171 fMult(tmpI, (-cos_F[64 - band - 1])); /* sum should be <= 1
2172 because of sin/cos
2173 multiplication */
2174 ppQmfBufferOutImag_F[i + ov_len][band] =
2175 fMult(tmpR, (-cos_F[64 - band - 1])) +
2176 fMult(tmpI, cos_F[band]); /* sum should by <= 1 because of sin/cos
2177 multiplication */
2178 }
2179 }
2180 }
2181 }
2182
2183 *scale_hb = EXP2SCALE(scale_factor_hbe);
2184 }
2185
GetxOverBandQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer)2186 int* GetxOverBandQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
2187 if (hQmfTransposer)
2188 return hQmfTransposer->xOverQmf;
2189 else
2190 return NULL;
2191 }
2192
Get41SbrQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer)2193 int Get41SbrQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
2194 if (hQmfTransposer != NULL)
2195 return hQmfTransposer->bSbr41;
2196 else
2197 return 0;
2198 }
2199