• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     FDK_ASSERT((!hQmfTransposer->bSbr41 && hQmfTransposer->startBand <= 32) ||
1060                (hQmfTransposer->bSbr41 &&
1061                 hQmfTransposer->startBand <=
1062                     16)); /* is checked by resetFreqBandTables() */
1063     hQmfTransposer->stopBand = FreqBandTable[0][NSfb[0]];
1064 
1065     hQmfTransposer->synthSize =
1066         4 * ((hQmfTransposer->startBand + 4) / 8 + 1); /* 8, 12, 16, 20 */
1067     hQmfTransposer->kstart = startSubband2kL[hQmfTransposer->startBand];
1068 
1069     /* don't know where to take this information from */
1070     /* hQmfTransposer->bSbr41 = bSbr41;               */
1071 
1072     if (hQmfTransposer->bSbr41) {
1073       if (hQmfTransposer->kstart + hQmfTransposer->synthSize > 16)
1074         hQmfTransposer->kstart = 16 - hQmfTransposer->synthSize;
1075     } else if (hQmfTransposer->timeDomainWinLen == 768) {
1076       if (hQmfTransposer->kstart + hQmfTransposer->synthSize > 24)
1077         hQmfTransposer->kstart = 24 - hQmfTransposer->synthSize;
1078     }
1079 
1080     hQmfTransposer->synthesisQmfPreModCos_F =
1081         &preModCos[hQmfTransposer->kstart];
1082     hQmfTransposer->synthesisQmfPreModSin_F =
1083         &preModSin[hQmfTransposer->kstart];
1084 
1085     L = 2 * hQmfTransposer->synthSize; /* 8, 16, 24, 32, 40 */
1086                                        /* Change analysis post twiddles */
1087 
1088     switch (L) {
1089       case 8:
1090         tmp_t_cos = post_twiddle_cos_8;
1091         tmp_t_sin = post_twiddle_sin_8;
1092         break;
1093       case 16:
1094         tmp_t_cos = post_twiddle_cos_16;
1095         tmp_t_sin = post_twiddle_sin_16;
1096         break;
1097       case 24:
1098         tmp_t_cos = post_twiddle_cos_24;
1099         tmp_t_sin = post_twiddle_sin_24;
1100         break;
1101       case 32:
1102         tmp_t_cos = post_twiddle_cos_32;
1103         tmp_t_sin = post_twiddle_sin_32;
1104         break;
1105       case 40:
1106         tmp_t_cos = post_twiddle_cos_40;
1107         tmp_t_sin = post_twiddle_sin_40;
1108         break;
1109       default:
1110         return SBRDEC_UNSUPPORTED_CONFIG;
1111     }
1112 
1113     qmfErr = qmfInitSynthesisFilterBank(
1114         &hQmfTransposer->HBESynthesisQMF, hQmfTransposer->synQmfStates,
1115         hQmfTransposer->noCols, 0, hQmfTransposer->synthSize,
1116         hQmfTransposer->synthSize, 1);
1117     if (qmfErr != 0) {
1118       return SBRDEC_UNSUPPORTED_CONFIG;
1119     }
1120 
1121     qmfErr = qmfInitAnalysisFilterBank(
1122         &hQmfTransposer->HBEAnalysiscQMF, hQmfTransposer->anaQmfStates,
1123         hQmfTransposer->noCols / 2, 0, 2 * hQmfTransposer->synthSize,
1124         2 * hQmfTransposer->synthSize, 0);
1125 
1126     if (qmfErr != 0) {
1127       return SBRDEC_UNSUPPORTED_CONFIG;
1128     }
1129 
1130     hQmfTransposer->HBEAnalysiscQMF.t_cos = tmp_t_cos;
1131     hQmfTransposer->HBEAnalysiscQMF.t_sin = tmp_t_sin;
1132 
1133     FDKmemset(hQmfTransposer->xOverQmf, 0,
1134               MAX_NUM_PATCHES * sizeof(int)); /* global */
1135     sfb = 0;
1136     if (hQmfTransposer->bSbr41) {
1137       stopPatch = MAX_NUM_PATCHES;
1138       hQmfTransposer->maxStretch = MAX_STRETCH_HBE;
1139     } else {
1140       stopPatch = MAX_STRETCH_HBE;
1141     }
1142 
1143     for (patch = 1; patch <= stopPatch; patch++) {
1144       while (sfb <= NSfb[0] &&
1145              FreqBandTable[0][sfb] <= patch * hQmfTransposer->startBand)
1146         sfb++;
1147       if (sfb <= NSfb[0]) {
1148         /* If the distance is larger than three QMF bands - try aligning to high
1149          * resolution frequency bands instead. */
1150         if ((patch * hQmfTransposer->startBand - FreqBandTable[0][sfb - 1]) <=
1151             3) {
1152           hQmfTransposer->xOverQmf[patch - 1] = FreqBandTable[0][sfb - 1];
1153         } else {
1154           int sfb_tmp = 0;
1155           while (sfb_tmp <= NSfb[1] &&
1156                  FreqBandTable[1][sfb_tmp] <= patch * hQmfTransposer->startBand)
1157             sfb_tmp++;
1158           hQmfTransposer->xOverQmf[patch - 1] = FreqBandTable[1][sfb_tmp - 1];
1159         }
1160       } else {
1161         hQmfTransposer->xOverQmf[patch - 1] = hQmfTransposer->stopBand;
1162         hQmfTransposer->maxStretch = fMin(patch, MAX_STRETCH_HBE);
1163         break;
1164       }
1165     }
1166 
1167     hQmfTransposer->highband_exp[0] = 0;
1168     hQmfTransposer->highband_exp[1] = 0;
1169     hQmfTransposer->target_exp[0] = 0;
1170     hQmfTransposer->target_exp[1] = 0;
1171   }
1172 
1173   return SBRDEC_OK;
1174 }
1175 
QmfTransposerClose(HANDLE_HBE_TRANSPOSER hQmfTransposer)1176 void QmfTransposerClose(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
1177   int i;
1178 
1179   if (hQmfTransposer != NULL) {
1180     if (hQmfTransposer->inBuf_F) FDKfree(hQmfTransposer->inBuf_F);
1181 
1182     if (hQmfTransposer->qmfInBufReal_F) {
1183       for (i = 0; i < hQmfTransposer->qmfInBufSize; i++) {
1184         FDKafree(hQmfTransposer->qmfInBufReal_F[i]);
1185       }
1186       FDKfree(hQmfTransposer->qmfInBufReal_F);
1187     }
1188 
1189     if (hQmfTransposer->qmfInBufImag_F) {
1190       for (i = 0; i < hQmfTransposer->qmfInBufSize; i++) {
1191         FDKafree(hQmfTransposer->qmfInBufImag_F[i]);
1192       }
1193       FDKfree(hQmfTransposer->qmfInBufImag_F);
1194     }
1195 
1196     if (hQmfTransposer->qmfHBEBufReal_F) {
1197       for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1198         FDKfree(hQmfTransposer->qmfHBEBufReal_F[i]);
1199       }
1200       FDKfree(hQmfTransposer->qmfHBEBufReal_F);
1201     }
1202 
1203     if (hQmfTransposer->qmfHBEBufImag_F) {
1204       for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1205         FDKfree(hQmfTransposer->qmfHBEBufImag_F[i]);
1206       }
1207       FDKfree(hQmfTransposer->qmfHBEBufImag_F);
1208     }
1209 
1210     FDKfree(hQmfTransposer->qmfBufferCodecTempSlot_F);
1211 
1212     FDKfree(hQmfTransposer);
1213   }
1214 }
1215 
scaleUp(FIXP_DBL * real_m,FIXP_DBL * imag_m,INT * _e)1216 inline void scaleUp(FIXP_DBL* real_m, FIXP_DBL* imag_m, INT* _e) {
1217   INT reserve;
1218   /* shift gc_r and gc_i up if possible */
1219   reserve = CntLeadingZeros((INT(*real_m) ^ INT((*real_m >> 31))) |
1220                             (INT(*imag_m) ^ INT((*imag_m >> 31)))) -
1221             1;
1222   reserve = fMax(reserve - 1,
1223                  0); /* Leave one bit headroom such that (real_m^2 + imag_m^2)
1224                         does not overflow later if both are 0x80000000. */
1225   reserve = fMin(reserve, *_e);
1226   FDK_ASSERT(reserve >= 0);
1227   *real_m <<= reserve;
1228   *imag_m <<= reserve;
1229   *_e -= reserve;
1230 }
1231 
calculateCenterFIXP(FIXP_DBL gammaVecReal,FIXP_DBL gammaVecImag,FIXP_DBL * centerReal,FIXP_DBL * centerImag,INT * exponent,int stretch,int mult)1232 static void calculateCenterFIXP(FIXP_DBL gammaVecReal, FIXP_DBL gammaVecImag,
1233                                 FIXP_DBL* centerReal, FIXP_DBL* centerImag,
1234                                 INT* exponent, int stretch, int mult) {
1235   scaleUp(&gammaVecReal, &gammaVecImag, exponent);
1236   FIXP_DBL energy = fPow2Div2(gammaVecReal) + fPow2Div2(gammaVecImag);
1237 
1238   if (energy != FL2FXCONST_DBL(0.f)) {
1239     FIXP_DBL gc_r_m, gc_i_m, factor_m = (FIXP_DBL)0;
1240     INT factor_e, gc_e;
1241     factor_e = 2 * (*exponent) + 1;
1242 
1243     switch (stretch) {
1244       case 2:
1245         factor_m = invFourthRootNorm2(energy, &factor_e);
1246         break;
1247       case 3:
1248         factor_m = invCubeRootNorm2(energy, &factor_e);
1249         break;
1250       case 4:
1251         factor_m = inv3EigthRootNorm2(energy, &factor_e);
1252         break;
1253     }
1254 
1255     gc_r_m = fMultDiv2(gammaVecReal,
1256                        factor_m); /* exponent = HBE_SCALE + factor_e + 1 */
1257     gc_i_m = fMultDiv2(gammaVecImag,
1258                        factor_m); /* exponent = HBE_SCALE + factor_e + 1*/
1259     gc_e = *exponent + factor_e + 1;
1260 
1261     scaleUp(&gc_r_m, &gc_i_m, &gc_e);
1262 
1263     switch (mult) {
1264       case 0:
1265         *centerReal = gc_r_m;
1266         *centerImag = gc_i_m;
1267         break;
1268       case 1:
1269         *centerReal = fPow2Div2(gc_r_m) - fPow2Div2(gc_i_m);
1270         *centerImag = fMult(gc_r_m, gc_i_m);
1271         gc_e = 2 * gc_e + 1;
1272         break;
1273       case 2:
1274         FIXP_DBL tmp_r = gc_r_m;
1275         FIXP_DBL tmp_i = gc_i_m;
1276         gc_r_m = fPow2Div2(gc_r_m) - fPow2Div2(gc_i_m);
1277         gc_i_m = fMult(tmp_r, gc_i_m);
1278         gc_e = 3 * gc_e + 1 + 1;
1279         cplxMultDiv2(&centerReal[0], &centerImag[0], gc_r_m, gc_i_m, tmp_r,
1280                      tmp_i);
1281         break;
1282     }
1283 
1284     scaleUp(centerReal, centerImag, &gc_e);
1285 
1286     FDK_ASSERT(gc_e >= 0);
1287     *exponent = gc_e;
1288   } else {
1289     *centerReal = energy; /* energy = 0 */
1290     *centerImag = energy; /* energy = 0 */
1291     *exponent = (INT)energy;
1292   }
1293 }
1294 
getHBEScaleFactorFrame(const int bSbr41,const int maxStretch,const int pitchInBins)1295 static int getHBEScaleFactorFrame(const int bSbr41, const int maxStretch,
1296                                   const int pitchInBins) {
1297   if (pitchInBins >= pmin * (1 + bSbr41)) {
1298     /* crossproducts enabled */
1299     return 26;
1300   } else {
1301     return (maxStretch == 2) ? 24 : 25;
1302   }
1303 }
1304 
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)1305 static void addHighBandPart(FIXP_DBL g_r_m, FIXP_DBL g_i_m, INT g_e,
1306                             FIXP_DBL mult, FIXP_DBL gammaCenterReal_m,
1307                             FIXP_DBL gammaCenterImag_m, INT gammaCenter_e,
1308                             INT stretch, INT scale_factor_hbe,
1309                             FIXP_DBL* qmfHBEBufReal_F,
1310                             FIXP_DBL* qmfHBEBufImag_F) {
1311   if ((g_r_m | g_i_m) != FL2FXCONST_DBL(0.f)) {
1312     FIXP_DBL factor_m = (FIXP_DBL)0;
1313     INT factor_e;
1314     INT add = (stretch == 4) ? 1 : 0;
1315     INT shift = (stretch == 4) ? 1 : 2;
1316 
1317     scaleUp(&g_r_m, &g_i_m, &g_e);
1318     FIXP_DBL energy = fPow2AddDiv2(fPow2Div2(g_r_m), g_i_m);
1319     factor_e = 2 * g_e + 1;
1320 
1321     switch (stretch) {
1322       case 2:
1323         factor_m = invFourthRootNorm2(energy, &factor_e);
1324         break;
1325       case 3:
1326         factor_m = invCubeRootNorm2(energy, &factor_e);
1327         break;
1328       case 4:
1329         factor_m = inv3EigthRootNorm2(energy, &factor_e);
1330         break;
1331     }
1332 
1333     factor_m = fMult(factor_m, mult);
1334 
1335     FIXP_DBL tmp_r, tmp_i;
1336     cplxMultDiv2(&tmp_r, &tmp_i, g_r_m, g_i_m, gammaCenterReal_m,
1337                  gammaCenterImag_m);
1338 
1339     g_r_m = fMultDiv2(tmp_r, factor_m) << shift;
1340     g_i_m = fMultDiv2(tmp_i, factor_m) << shift;
1341     g_e = scale_factor_hbe - (g_e + factor_e + gammaCenter_e + add);
1342     fMax((INT)0, g_e);
1343     *qmfHBEBufReal_F += g_r_m >> g_e;
1344     *qmfHBEBufImag_F += g_i_m >> g_e;
1345   }
1346 }
1347 
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)1348 void QmfTransposerApply(HANDLE_HBE_TRANSPOSER hQmfTransposer,
1349                         FIXP_DBL** qmfBufferCodecReal,
1350                         FIXP_DBL** qmfBufferCodecImag, int nColsIn,
1351                         FIXP_DBL** ppQmfBufferOutReal_F,
1352                         FIXP_DBL** ppQmfBufferOutImag_F,
1353                         FIXP_DBL lpcFilterStatesReal[2 + (3 * (4))][(64)],
1354                         FIXP_DBL lpcFilterStatesImag[2 + (3 * (4))][(64)],
1355                         int pitchInBins, int scale_lb, int scale_hbe,
1356                         int* scale_hb, int timeStep, int firstSlotOffsset,
1357                         int ov_len,
1358                         KEEP_STATES_SYNCED_MODE keepStatesSyncedMode) {
1359   int i, j, stretch, band, sourceband, r, s;
1360   int qmfVocoderColsIn = hQmfTransposer->noCols / 2;
1361   int bSbr41 = hQmfTransposer->bSbr41;
1362 
1363   const int winLength[3] = {10, 8, 6};
1364   const int slotOffset = 6; /* hQmfTransposer->winLen-6; */
1365 
1366   int qmfOffset = 2 * hQmfTransposer->kstart;
1367   int scale_border = (nColsIn == 64) ? 32 : nColsIn;
1368 
1369   INT slot_stretch4[9] = {0, 0, 0, 0, 2, 4, 6, 8, 10};
1370   INT slot_stretch2[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
1371   INT slot_stretch3[10] = {0, 0, 0, 1, 3, 4, 6, 7, 9, 10};
1372   INT filt_stretch3[10] = {0, 0, 0, 1, 0, 1, 0, 1, 0, 1};
1373   INT filt_dummy[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1374   INT* pSlotStretch;
1375   INT* pFilt;
1376 
1377   int offset = 0; /* where to take  QmfTransposer data */
1378 
1379   int signPreMod =
1380       (hQmfTransposer->synthesisQmfPreModCos_F[0] < FL2FXCONST_DBL(0.f)) ? 1
1381                                                                          : -1;
1382 
1383   int scale_factor_hbe =
1384       getHBEScaleFactorFrame(bSbr41, hQmfTransposer->maxStretch, pitchInBins);
1385 
1386   if (keepStatesSyncedMode != KEEP_STATES_SYNCED_OFF) {
1387     offset = hQmfTransposer->noCols - ov_len - LPC_ORDER;
1388   }
1389 
1390   hQmfTransposer->highband_exp[0] = hQmfTransposer->highband_exp[1];
1391   hQmfTransposer->target_exp[0] = hQmfTransposer->target_exp[1];
1392 
1393   hQmfTransposer->highband_exp[1] = scale_factor_hbe;
1394   hQmfTransposer->target_exp[1] =
1395       fixMax(hQmfTransposer->highband_exp[1], hQmfTransposer->highband_exp[0]);
1396 
1397   scale_factor_hbe = hQmfTransposer->target_exp[1];
1398 
1399   int shift_ov = hQmfTransposer->target_exp[0] - hQmfTransposer->target_exp[1];
1400 
1401   if (shift_ov != 0) {
1402     for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
1403       for (band = 0; band < QMF_SYNTH_CHANNELS; band++) {
1404         if (shift_ov >= 0) {
1405           hQmfTransposer->qmfHBEBufReal_F[i][band] <<= shift_ov;
1406           hQmfTransposer->qmfHBEBufImag_F[i][band] <<= shift_ov;
1407         } else {
1408           hQmfTransposer->qmfHBEBufReal_F[i][band] >>= (-shift_ov);
1409           hQmfTransposer->qmfHBEBufImag_F[i][band] >>= (-shift_ov);
1410         }
1411       }
1412     }
1413   }
1414 
1415   if ((keepStatesSyncedMode == KEEP_STATES_SYNCED_OFF) && shift_ov != 0) {
1416     for (i = timeStep * firstSlotOffsset; i < ov_len; i++) {
1417       for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
1418            band++) {
1419         if (shift_ov >= 0) {
1420           ppQmfBufferOutReal_F[i][band] <<= shift_ov;
1421           ppQmfBufferOutImag_F[i][band] <<= shift_ov;
1422         } else {
1423           ppQmfBufferOutReal_F[i][band] >>= (-shift_ov);
1424           ppQmfBufferOutImag_F[i][band] >>= (-shift_ov);
1425         }
1426       }
1427     }
1428 
1429     /* shift lpc filterstates */
1430     for (i = 0; i < timeStep * firstSlotOffsset + LPC_ORDER; i++) {
1431       for (band = 0; band < (64); band++) {
1432         if (shift_ov >= 0) {
1433           lpcFilterStatesReal[i][band] <<= shift_ov;
1434           lpcFilterStatesImag[i][band] <<= shift_ov;
1435         } else {
1436           lpcFilterStatesReal[i][band] >>= (-shift_ov);
1437           lpcFilterStatesImag[i][band] >>= (-shift_ov);
1438         }
1439       }
1440     }
1441   }
1442 
1443   FIXP_DBL twid_m_new[3][2]; /* [stretch][cos/sin] */
1444   INT stepsize = 1 + !bSbr41, sine_offset = 24, mod = 96;
1445   INT mult[3] = {1, 2, 3};
1446 
1447   for (s = 0; s <= MAX_STRETCH_HBE - 2; s++) {
1448     twid_m_new[s][0] = twiddle[(mult[s] * (stepsize * pitchInBins)) % mod];
1449     twid_m_new[s][1] =
1450         twiddle[((mult[s] * (stepsize * pitchInBins)) + sine_offset) % mod];
1451   }
1452 
1453   /* Time-stretch */
1454   for (j = 0; j < qmfVocoderColsIn; j++) {
1455     int sign = -1, k, z, addrshift, codecTemp_e;
1456     /* update inbuf */
1457     for (i = 0; i < hQmfTransposer->synthSize; i++) {
1458       hQmfTransposer->inBuf_F[i] =
1459           hQmfTransposer->inBuf_F[i + 2 * hQmfTransposer->synthSize];
1460     }
1461 
1462     /* run synthesis for two sbr slots as transposer uses
1463     half slots double bands representation */
1464     for (z = 0; z < 2; z++) {
1465       int scale_factor = ((nColsIn == 64) && ((2 * j + z) < scale_border))
1466                              ? scale_lb
1467                              : scale_hbe;
1468       codecTemp_e = scale_factor - 1; /* -2 for Div2 and cos/sin scale of 1 */
1469 
1470       for (k = 0; k < hQmfTransposer->synthSize; k++) {
1471         int ki = hQmfTransposer->kstart + k;
1472         hQmfTransposer->qmfBufferCodecTempSlot_F[k] =
1473             fMultDiv2(signPreMod * hQmfTransposer->synthesisQmfPreModCos_F[k],
1474                       qmfBufferCodecReal[2 * j + z][ki]);
1475         hQmfTransposer->qmfBufferCodecTempSlot_F[k] +=
1476             fMultDiv2(signPreMod * hQmfTransposer->synthesisQmfPreModSin_F[k],
1477                       qmfBufferCodecImag[2 * j + z][ki]);
1478       }
1479 
1480       C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1481 
1482       qmfSynthesisFilteringSlot(
1483           &hQmfTransposer->HBESynthesisQMF,
1484           hQmfTransposer->qmfBufferCodecTempSlot_F, NULL, 0,
1485           -7 - hQmfTransposer->HBESynthesisQMF.filterScale - codecTemp_e + 1,
1486           hQmfTransposer->inBuf_F + hQmfTransposer->synthSize * (z + 1), 1,
1487           pWorkBuffer);
1488 
1489       C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1490     }
1491 
1492     C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1493 
1494     qmfAnalysisFilteringSlot(&hQmfTransposer->HBEAnalysiscQMF,
1495                              hQmfTransposer->qmfInBufReal_F[QMF_WIN_LEN - 1],
1496                              hQmfTransposer->qmfInBufImag_F[QMF_WIN_LEN - 1],
1497                              hQmfTransposer->inBuf_F + 1, 1, pWorkBuffer);
1498 
1499     C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
1500 
1501     if ((keepStatesSyncedMode == KEEP_STATES_SYNCED_NORMAL) &&
1502         j <= qmfVocoderColsIn - ((LPC_ORDER + ov_len + QMF_WIN_LEN - 1) >> 1)) {
1503       /* update in buffer */
1504       for (i = 0; i < QMF_WIN_LEN - 1; i++) {
1505         FDKmemcpy(
1506             hQmfTransposer->qmfInBufReal_F[i],
1507             hQmfTransposer->qmfInBufReal_F[i + 1],
1508             sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
1509         FDKmemcpy(
1510             hQmfTransposer->qmfInBufImag_F[i],
1511             hQmfTransposer->qmfInBufImag_F[i + 1],
1512             sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
1513       }
1514       continue;
1515     }
1516 
1517     for (stretch = 2; stretch <= hQmfTransposer->maxStretch; stretch++) {
1518       int start = slotOffset - winLength[stretch - 2] / 2;
1519       int stop = slotOffset + winLength[stretch - 2] / 2;
1520 
1521       FIXP_DBL factor = FL2FXCONST_DBL(1.f / 3.f);
1522 
1523       for (band = hQmfTransposer->xOverQmf[stretch - 2];
1524            band < hQmfTransposer->xOverQmf[stretch - 1]; band++) {
1525         FIXP_DBL gammaCenterReal_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0},
1526                  gammaCenterImag_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0};
1527         INT gammaCenter_e[2] = {0, 0};
1528 
1529         FIXP_DBL gammaVecReal_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0},
1530                  gammaVecImag_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0};
1531         INT gammaVec_e[2] = {0, 0};
1532 
1533         FIXP_DBL wingain = (FIXP_DBL)0;
1534 
1535         gammaCenter_e[0] =
1536             SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1537         gammaCenter_e[1] =
1538             SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1539 
1540         /* interpolation filters for 3rd order */
1541         sourceband = 2 * band / stretch - qmfOffset;
1542         FDK_ASSERT(sourceband >= 0);
1543 
1544         /* maximum gammaCenter_e == 20 */
1545         calculateCenterFIXP(
1546             hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband],
1547             hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband],
1548             &gammaCenterReal_m[0], &gammaCenterImag_m[0], &gammaCenter_e[0],
1549             stretch, stretch - 2);
1550 
1551         if (stretch == 4) {
1552           r = band - 2 * (band / 2);
1553           sourceband += (r == 0) ? -1 : 1;
1554           pSlotStretch = slot_stretch4;
1555           factor = FL2FXCONST_DBL(2.f / 3.f);
1556           pFilt = filt_dummy;
1557         } else if (stretch == 2) {
1558           r = 0;
1559           sourceband = 2 * band / stretch - qmfOffset;
1560           pSlotStretch = slot_stretch2;
1561           factor = FL2FXCONST_DBL(1.f / 3.f);
1562           pFilt = filt_dummy;
1563         } else {
1564           r = 2 * band - 3 * (2 * band / 3);
1565           sourceband = 2 * band / stretch - qmfOffset;
1566           pSlotStretch = slot_stretch3;
1567           factor = FL2FXCONST_DBL(1.4142f / 3.0f);
1568           pFilt = filt_stretch3;
1569         }
1570 
1571         if (r == 2) {
1572           calculateCenterFIXP(
1573               hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband + 1],
1574               hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband + 1],
1575               &gammaCenterReal_m[1], &gammaCenterImag_m[1], &gammaCenter_e[1],
1576               stretch, stretch - 2);
1577 
1578           factor = FL2FXCONST_DBL(1.4142f / 6.0f);
1579         }
1580 
1581         if (r == 2) {
1582           for (k = start; k < stop; k++) {
1583             gammaVecReal_m[0] =
1584                 hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband];
1585             gammaVecReal_m[1] =
1586                 hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband + 1];
1587             gammaVecImag_m[0] =
1588                 hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband];
1589             gammaVecImag_m[1] =
1590                 hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband + 1];
1591             gammaVec_e[0] = gammaVec_e[1] =
1592                 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1593 
1594             if (pFilt[k] == 1) {
1595               FIXP_DBL tmpRealF = gammaVecReal_m[0], tmpImagF;
1596               gammaVecReal_m[0] =
1597                   (fMult(gammaVecReal_m[0], hintReal_F[sourceband % 4][1]) -
1598                    fMult(gammaVecImag_m[0],
1599                          hintReal_F[(sourceband + 3) % 4][1])) >>
1600                   1; /* sum should be <= 1 because of sin/cos multiplication */
1601               gammaVecImag_m[0] =
1602                   (fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][1]) +
1603                    fMult(gammaVecImag_m[0], hintReal_F[sourceband % 4][1])) >>
1604                   1; /* sum should be <= 1 because of sin/cos multiplication */
1605 
1606               tmpRealF = hQmfTransposer
1607                              ->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband];
1608               tmpImagF = hQmfTransposer
1609                              ->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband];
1610 
1611               gammaVecReal_m[0] +=
1612                   (fMult(tmpRealF, hintReal_F[sourceband % 4][1]) -
1613                    fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][1])) >>
1614                   1; /* sum should be <= 1 because of sin/cos multiplication */
1615               gammaVecImag_m[0] +=
1616                   (fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][1]) +
1617                    fMult(tmpImagF, hintReal_F[sourceband % 4][1])) >>
1618                   1; /* sum should be <= 1 because of sin/cos multiplication */
1619               gammaVec_e[0]++;
1620 
1621               tmpRealF = gammaVecReal_m[1];
1622 
1623               gammaVecReal_m[1] =
1624                   (fMult(gammaVecReal_m[1], hintReal_F[sourceband % 4][2]) -
1625                    fMult(gammaVecImag_m[1],
1626                          hintReal_F[(sourceband + 3) % 4][2])) >>
1627                   1;
1628               gammaVecImag_m[1] =
1629                   (fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][2]) +
1630                    fMult(gammaVecImag_m[1], hintReal_F[sourceband % 4][2])) >>
1631                   1;
1632 
1633               tmpRealF =
1634                   hQmfTransposer
1635                       ->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband + 1];
1636               tmpImagF =
1637                   hQmfTransposer
1638                       ->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband + 1];
1639 
1640               gammaVecReal_m[1] +=
1641                   (fMult(tmpRealF, hintReal_F[sourceband % 4][2]) -
1642                    fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][2])) >>
1643                   1;
1644               gammaVecImag_m[1] +=
1645                   (fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][2]) +
1646                    fMult(tmpImagF, hintReal_F[sourceband % 4][2])) >>
1647                   1;
1648               gammaVec_e[1]++;
1649             }
1650 
1651             addHighBandPart(gammaVecReal_m[1], gammaVecImag_m[1], gammaVec_e[1],
1652                             factor, gammaCenterReal_m[0], gammaCenterImag_m[0],
1653                             gammaCenter_e[0], stretch, scale_factor_hbe,
1654                             &hQmfTransposer->qmfHBEBufReal_F[k][band],
1655                             &hQmfTransposer->qmfHBEBufImag_F[k][band]);
1656 
1657             addHighBandPart(gammaVecReal_m[0], gammaVecImag_m[0], gammaVec_e[0],
1658                             factor, gammaCenterReal_m[1], gammaCenterImag_m[1],
1659                             gammaCenter_e[1], stretch, scale_factor_hbe,
1660                             &hQmfTransposer->qmfHBEBufReal_F[k][band],
1661                             &hQmfTransposer->qmfHBEBufImag_F[k][band]);
1662           }
1663         } else {
1664           for (k = start; k < stop; k++) {
1665             gammaVecReal_m[0] =
1666                 hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband];
1667             gammaVecImag_m[0] =
1668                 hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband];
1669             gammaVec_e[0] =
1670                 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1671 
1672             if (pFilt[k] == 1) {
1673               FIXP_DBL tmpRealF = gammaVecReal_m[0], tmpImagF;
1674               gammaVecReal_m[0] =
1675                   (fMult(gammaVecReal_m[0], hintReal_F[sourceband % 4][1]) -
1676                    fMult(gammaVecImag_m[0],
1677                          hintReal_F[(sourceband + 3) % 4][1])) >>
1678                   1; /* sum should be <= 1 because of sin/cos multiplication */
1679               gammaVecImag_m[0] =
1680                   (fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][1]) +
1681                    fMult(gammaVecImag_m[0], hintReal_F[sourceband % 4][1])) >>
1682                   1; /* sum should be <= 1 because of sin/cos multiplication */
1683 
1684               tmpRealF = hQmfTransposer
1685                              ->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband];
1686               tmpImagF = hQmfTransposer
1687                              ->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband];
1688 
1689               gammaVecReal_m[0] +=
1690                   (fMult(tmpRealF, hintReal_F[sourceband % 4][1]) -
1691                    fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][1])) >>
1692                   1; /* sum should be <= 1 because of sin/cos multiplication */
1693               gammaVecImag_m[0] +=
1694                   (fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][1]) +
1695                    fMult(tmpImagF, hintReal_F[sourceband % 4][1])) >>
1696                   1; /* sum should be <= 1 because of sin/cos multiplication */
1697               gammaVec_e[0]++;
1698             }
1699 
1700             addHighBandPart(gammaVecReal_m[0], gammaVecImag_m[0], gammaVec_e[0],
1701                             factor, gammaCenterReal_m[0], gammaCenterImag_m[0],
1702                             gammaCenter_e[0], stretch, scale_factor_hbe,
1703                             &hQmfTransposer->qmfHBEBufReal_F[k][band],
1704                             &hQmfTransposer->qmfHBEBufImag_F[k][band]);
1705           }
1706         }
1707 
1708         /* pitchInBins is given with the resolution of a 768 bins FFT and we
1709          * need 64 QMF units so factor 768/64 = 12 */
1710         if (pitchInBins >= pmin * (1 + bSbr41)) {
1711           int tr, ti1, ti2, mTr = 0, ts1 = 0, ts2 = 0, mVal_e = 0, temp_e = 0;
1712           int sqmag0_e =
1713               SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1714 
1715           FIXP_DBL mVal_F = FL2FXCONST_DBL(0.f), sqmag0_F, sqmag1_F, sqmag2_F,
1716                    temp_F, f1_F; /* all equal exponent */
1717           sign = -1;
1718 
1719           sourceband = 2 * band / stretch - qmfOffset; /* consistent with the
1720                                                           already computed for
1721                                                           stretch = 3,4. */
1722           FDK_ASSERT(sourceband >= 0);
1723 
1724           FIXP_DBL sqmag0R_F =
1725               hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband];
1726           FIXP_DBL sqmag0I_F =
1727               hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband];
1728           scaleUp(&sqmag0R_F, &sqmag0I_F, &sqmag0_e);
1729 
1730           sqmag0_F = fPow2Div2(sqmag0R_F);
1731           sqmag0_F += fPow2Div2(sqmag0I_F);
1732           sqmag0_e = 2 * sqmag0_e + 1;
1733 
1734           for (tr = 1; tr < stretch; tr++) {
1735             int sqmag1_e =
1736                 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1737             int sqmag2_e =
1738                 SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1739 
1740             FIXP_DBL tmp_band = band_F[band];
1741             FIXP_DBL tr_p =
1742                 fMult(p_F[pitchInBins] >> bSbr41, tr_str[tr - 1]); /* scale 7 */
1743             f1_F =
1744                 fMult(tmp_band - tr_p, stretchfac[stretch - 2]); /* scale 7 */
1745             ti1 = (INT)(f1_F >> (DFRACT_BITS - 1 - 7)) - qmfOffset;
1746             ti2 = (INT)(((f1_F) + ((p_F[pitchInBins] >> bSbr41) >> 2)) >>
1747                         (DFRACT_BITS - 1 - 7)) -
1748                   qmfOffset;
1749 
1750             if (ti1 >= 0 && ti2 < 2 * hQmfTransposer->synthSize) {
1751               FIXP_DBL sqmag1R_F =
1752                   hQmfTransposer->qmfInBufReal_F[slotOffset][ti1];
1753               FIXP_DBL sqmag1I_F =
1754                   hQmfTransposer->qmfInBufImag_F[slotOffset][ti1];
1755               scaleUp(&sqmag1R_F, &sqmag1I_F, &sqmag1_e);
1756               sqmag1_F = fPow2Div2(sqmag1R_F);
1757               sqmag1_F += fPow2Div2(sqmag1I_F);
1758               sqmag1_e = 2 * sqmag1_e + 1;
1759 
1760               FIXP_DBL sqmag2R_F =
1761                   hQmfTransposer->qmfInBufReal_F[slotOffset][ti2];
1762               FIXP_DBL sqmag2I_F =
1763                   hQmfTransposer->qmfInBufImag_F[slotOffset][ti2];
1764               scaleUp(&sqmag2R_F, &sqmag2I_F, &sqmag2_e);
1765               sqmag2_F = fPow2Div2(sqmag2R_F);
1766               sqmag2_F += fPow2Div2(sqmag2I_F);
1767               sqmag2_e = 2 * sqmag2_e + 1;
1768 
1769               int shift1 = fMin(fMax(sqmag1_e, sqmag2_e) - sqmag1_e, 31);
1770               int shift2 = fMin(fMax(sqmag1_e, sqmag2_e) - sqmag2_e, 31);
1771 
1772               temp_F = fMin((sqmag1_F >> shift1), (sqmag2_F >> shift2));
1773               temp_e = fMax(sqmag1_e, sqmag2_e);
1774 
1775               int shift3 = fMin(fMax(temp_e, mVal_e) - temp_e, 31);
1776               int shift4 = fMin(fMax(temp_e, mVal_e) - mVal_e, 31);
1777 
1778               if ((temp_F >> shift3) > (mVal_F >> shift4)) {
1779                 mVal_F = temp_F;
1780                 mVal_e = temp_e; /* equals sqmag2_e + shift2 */
1781                 mTr = tr;
1782                 ts1 = ti1;
1783                 ts2 = ti2;
1784               }
1785             }
1786           }
1787 
1788           int shift1 = fMin(fMax(sqmag0_e, mVal_e) - sqmag0_e, 31);
1789           int shift2 = fMin(fMax(sqmag0_e, mVal_e) - mVal_e, 31);
1790 
1791           if ((mVal_F >> shift2) > (sqmag0_F >> shift1) && ts1 >= 0 &&
1792               ts2 < 2 * hQmfTransposer->synthSize) {
1793             INT gammaOut_e[2];
1794             FIXP_DBL gammaOutReal_m[2], gammaOutImag_m[2];
1795             FIXP_DBL tmpReal_m = (FIXP_DBL)0, tmpImag_m = (FIXP_DBL)0;
1796 
1797             int Tcenter, Tvec;
1798 
1799             Tcenter = stretch - mTr; /* default phase power parameters */
1800             Tvec = mTr;
1801             switch (stretch) /* 2 tap block creation design depends on stretch
1802                                 order */
1803             {
1804               case 2:
1805                 wingain =
1806                     FL2FXCONST_DBL(5.f / 12.f); /* sum of taps divided by two */
1807 
1808                 if (hQmfTransposer->bXProducts[0]) {
1809                   gammaCenterReal_m[0] =
1810                       hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1811                   gammaCenterImag_m[0] =
1812                       hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1813 
1814                   for (k = 0; k < 2; k++) {
1815                     gammaVecReal_m[k] =
1816                         hQmfTransposer->qmfInBufReal_F[slotOffset - 1 + k][ts2];
1817                     gammaVecImag_m[k] =
1818                         hQmfTransposer->qmfInBufImag_F[slotOffset - 1 + k][ts2];
1819                   }
1820 
1821                   gammaCenter_e[0] = SCALE2EXP(
1822                       -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1823                   gammaVec_e[0] = gammaVec_e[1] = SCALE2EXP(
1824                       -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1825                 }
1826                 break;
1827 
1828               case 4:
1829                 wingain =
1830                     FL2FXCONST_DBL(6.f / 12.f); /* sum of taps divided by two */
1831                 if (hQmfTransposer->bXProducts[2]) {
1832                   if (mTr == 1) {
1833                     gammaCenterReal_m[0] =
1834                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1835                     gammaCenterImag_m[0] =
1836                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1837 
1838                     for (k = 0; k < 2; k++) {
1839                       gammaVecReal_m[k] =
1840                           hQmfTransposer
1841                               ->qmfInBufReal_F[slotOffset + 2 * (k - 1)][ts2];
1842                       gammaVecImag_m[k] =
1843                           hQmfTransposer
1844                               ->qmfInBufImag_F[slotOffset + 2 * (k - 1)][ts2];
1845                     }
1846                   } else if (mTr == 2) {
1847                     gammaCenterReal_m[0] =
1848                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1849                     gammaCenterImag_m[0] =
1850                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1851 
1852                     for (k = 0; k < 2; k++) {
1853                       gammaVecReal_m[k] =
1854                           hQmfTransposer
1855                               ->qmfInBufReal_F[slotOffset + (k - 1)][ts2];
1856                       gammaVecImag_m[k] =
1857                           hQmfTransposer
1858                               ->qmfInBufImag_F[slotOffset + (k - 1)][ts2];
1859                     }
1860                   } else /* (mTr == 3) */
1861                   {
1862                     sign = 1;
1863                     Tcenter = mTr; /* opposite phase power parameters as ts2 is
1864                                       center */
1865                     Tvec = stretch - mTr;
1866 
1867                     gammaCenterReal_m[0] =
1868                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
1869                     gammaCenterImag_m[0] =
1870                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
1871 
1872                     for (k = 0; k < 2; k++) {
1873                       gammaVecReal_m[k] =
1874                           hQmfTransposer
1875                               ->qmfInBufReal_F[slotOffset + 2 * (k - 1)][ts1];
1876                       gammaVecImag_m[k] =
1877                           hQmfTransposer
1878                               ->qmfInBufImag_F[slotOffset + 2 * (k - 1)][ts1];
1879                     }
1880                   }
1881 
1882                   gammaCenter_e[0] = SCALE2EXP(
1883                       -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1884                   gammaVec_e[0] = gammaVec_e[1] = SCALE2EXP(
1885                       -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1886                 }
1887                 break;
1888 
1889               case 3:
1890                 wingain = FL2FXCONST_DBL(5.6568f /
1891                                          12.f); /* sum of taps divided by two */
1892 
1893                 if (hQmfTransposer->bXProducts[1]) {
1894                   FIXP_DBL tmpReal_F, tmpImag_F;
1895                   if (mTr == 1) {
1896                     gammaCenterReal_m[0] =
1897                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1898                     gammaCenterImag_m[0] =
1899                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1900                     gammaVecReal_m[1] =
1901                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
1902                     gammaVecImag_m[1] =
1903                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
1904 
1905                     addrshift = -2;
1906                     tmpReal_F =
1907                         hQmfTransposer
1908                             ->qmfInBufReal_F[addrshift + slotOffset][ts2];
1909                     tmpImag_F =
1910                         hQmfTransposer
1911                             ->qmfInBufImag_F[addrshift + slotOffset][ts2];
1912 
1913                     gammaVecReal_m[0] =
1914                         (fMult(factors[ts2 % 4], tmpReal_F) -
1915                          fMult(factors[(ts2 + 3) % 4], tmpImag_F)) >>
1916                         1;
1917                     gammaVecImag_m[0] =
1918                         (fMult(factors[(ts2 + 3) % 4], tmpReal_F) +
1919                          fMult(factors[ts2 % 4], tmpImag_F)) >>
1920                         1;
1921 
1922                     tmpReal_F =
1923                         hQmfTransposer
1924                             ->qmfInBufReal_F[addrshift + 1 + slotOffset][ts2];
1925                     tmpImag_F =
1926                         hQmfTransposer
1927                             ->qmfInBufImag_F[addrshift + 1 + slotOffset][ts2];
1928 
1929                     gammaVecReal_m[0] +=
1930                         (fMult(factors[ts2 % 4], tmpReal_F) -
1931                          fMult(factors[(ts2 + 1) % 4], tmpImag_F)) >>
1932                         1;
1933                     gammaVecImag_m[0] +=
1934                         (fMult(factors[(ts2 + 1) % 4], tmpReal_F) +
1935                          fMult(factors[ts2 % 4], tmpImag_F)) >>
1936                         1;
1937 
1938                   } else /* (mTr == 2) */
1939                   {
1940                     sign = 1;
1941                     Tcenter = mTr; /* opposite phase power parameters as ts2 is
1942                                       center */
1943                     Tvec = stretch - mTr;
1944 
1945                     gammaCenterReal_m[0] =
1946                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
1947                     gammaCenterImag_m[0] =
1948                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
1949                     gammaVecReal_m[1] =
1950                         hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
1951                     gammaVecImag_m[1] =
1952                         hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
1953 
1954                     addrshift = -2;
1955                     tmpReal_F =
1956                         hQmfTransposer
1957                             ->qmfInBufReal_F[addrshift + slotOffset][ts1];
1958                     tmpImag_F =
1959                         hQmfTransposer
1960                             ->qmfInBufImag_F[addrshift + slotOffset][ts1];
1961 
1962                     gammaVecReal_m[0] =
1963                         (fMult(factors[ts1 % 4], tmpReal_F) -
1964                          fMult(factors[(ts1 + 3) % 4], tmpImag_F)) >>
1965                         1;
1966                     gammaVecImag_m[0] =
1967                         (fMult(factors[(ts1 + 3) % 4], tmpReal_F) +
1968                          fMult(factors[ts1 % 4], tmpImag_F)) >>
1969                         1;
1970 
1971                     tmpReal_F =
1972                         hQmfTransposer
1973                             ->qmfInBufReal_F[addrshift + 1 + slotOffset][ts1];
1974                     tmpImag_F =
1975                         hQmfTransposer
1976                             ->qmfInBufImag_F[addrshift + 1 + slotOffset][ts1];
1977 
1978                     gammaVecReal_m[0] +=
1979                         (fMult(factors[ts1 % 4], tmpReal_F) -
1980                          fMult(factors[(ts1 + 1) % 4], tmpImag_F)) >>
1981                         1;
1982                     gammaVecImag_m[0] +=
1983                         (fMult(factors[(ts1 + 1) % 4], tmpReal_F) +
1984                          fMult(factors[ts1 % 4], tmpImag_F)) >>
1985                         1;
1986                   }
1987 
1988                   gammaCenter_e[0] = gammaVec_e[1] = SCALE2EXP(
1989                       -hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
1990                   gammaVec_e[0] =
1991                       SCALE2EXP(
1992                           -hQmfTransposer->HBEAnalysiscQMF.outScalefactor) +
1993                       1;
1994                 }
1995                 break;
1996               default:
1997                 FDK_ASSERT(0);
1998                 break;
1999             } /* stretch cases */
2000 
2001             /* parameter controlled phase modification parts */
2002             /* maximum *_e == 20 */
2003             calculateCenterFIXP(gammaCenterReal_m[0], gammaCenterImag_m[0],
2004                                 &gammaCenterReal_m[0], &gammaCenterImag_m[0],
2005                                 &gammaCenter_e[0], stretch, Tcenter - 1);
2006             calculateCenterFIXP(gammaVecReal_m[0], gammaVecImag_m[0],
2007                                 &gammaVecReal_m[0], &gammaVecImag_m[0],
2008                                 &gammaVec_e[0], stretch, Tvec - 1);
2009             calculateCenterFIXP(gammaVecReal_m[1], gammaVecImag_m[1],
2010                                 &gammaVecReal_m[1], &gammaVecImag_m[1],
2011                                 &gammaVec_e[1], stretch, Tvec - 1);
2012 
2013             /*    Final multiplication of prepared parts  */
2014             for (k = 0; k < 2; k++) {
2015               gammaOutReal_m[k] =
2016                   fMultDiv2(gammaVecReal_m[k], gammaCenterReal_m[0]) -
2017                   fMultDiv2(gammaVecImag_m[k], gammaCenterImag_m[0]);
2018               gammaOutImag_m[k] =
2019                   fMultDiv2(gammaVecReal_m[k], gammaCenterImag_m[0]) +
2020                   fMultDiv2(gammaVecImag_m[k], gammaCenterReal_m[0]);
2021               gammaOut_e[k] = gammaCenter_e[0] + gammaVec_e[k] + 1;
2022             }
2023 
2024             scaleUp(&gammaOutReal_m[0], &gammaOutImag_m[0], &gammaOut_e[0]);
2025             scaleUp(&gammaOutReal_m[1], &gammaOutImag_m[1], &gammaOut_e[1]);
2026             FDK_ASSERT(gammaOut_e[0] >= 0);
2027             FDK_ASSERT(gammaOut_e[0] < 32);
2028 
2029             tmpReal_m = gammaOutReal_m[0];
2030             tmpImag_m = gammaOutImag_m[0];
2031 
2032             INT modstretch4 = ((stretch == 4) && (mTr == 2));
2033 
2034             FIXP_DBL cos_twid = twid_m_new[stretch - 2 - modstretch4][0];
2035             FIXP_DBL sin_twid = sign * twid_m_new[stretch - 2 - modstretch4][1];
2036 
2037             gammaOutReal_m[0] =
2038                 fMult(tmpReal_m, cos_twid) -
2039                 fMult(tmpImag_m, sin_twid); /* sum should be <= 1 because of
2040                                                sin/cos multiplication */
2041             gammaOutImag_m[0] =
2042                 fMult(tmpImag_m, cos_twid) +
2043                 fMult(tmpReal_m, sin_twid); /* sum should be <= 1 because of
2044                                                sin/cos multiplication */
2045 
2046             /* wingain */
2047             for (k = 0; k < 2; k++) {
2048               gammaOutReal_m[k] = (fMult(gammaOutReal_m[k], wingain) << 1);
2049               gammaOutImag_m[k] = (fMult(gammaOutImag_m[k], wingain) << 1);
2050             }
2051 
2052             gammaOutReal_m[1] >>= 1;
2053             gammaOutImag_m[1] >>= 1;
2054             gammaOut_e[0] += 2;
2055             gammaOut_e[1] += 2;
2056 
2057             /* OLA including window scaling by wingain/3 */
2058             for (k = 0; k < 2; k++) /* need k=1 to correspond to
2059                                        grainModImag[slotOffset] -> out to
2060                                        j*2+(slotOffset-offset)  */
2061             {
2062               hQmfTransposer->qmfHBEBufReal_F[(k + slotOffset - 1)][band] +=
2063                   gammaOutReal_m[k] >> (scale_factor_hbe - gammaOut_e[k]);
2064               hQmfTransposer->qmfHBEBufImag_F[(k + slotOffset - 1)][band] +=
2065                   gammaOutImag_m[k] >> (scale_factor_hbe - gammaOut_e[k]);
2066             }
2067           } /* mVal > qThrQMF * qThrQMF * sqmag0 && ts1 > 0 && ts2 < 64 */
2068         }   /* p >= pmin */
2069       }     /* for band */
2070     }       /* for stretch */
2071 
2072     for (i = 0; i < QMF_WIN_LEN - 1; i++) {
2073       FDKmemcpy(hQmfTransposer->qmfInBufReal_F[i],
2074                 hQmfTransposer->qmfInBufReal_F[i + 1],
2075                 sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
2076       FDKmemcpy(hQmfTransposer->qmfInBufImag_F[i],
2077                 hQmfTransposer->qmfInBufImag_F[i + 1],
2078                 sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
2079     }
2080 
2081     if (keepStatesSyncedMode != KEEP_STATES_SYNCED_NOOUT) {
2082       if (2 * j >= offset) {
2083         /* copy first two slots of internal buffer to output */
2084         if (keepStatesSyncedMode == KEEP_STATES_SYNCED_OUTDIFF) {
2085           for (i = 0; i < 2; i++) {
2086             FDKmemcpy(&ppQmfBufferOutReal_F[2 * j - offset + i]
2087                                            [hQmfTransposer->xOverQmf[0]],
2088                       &hQmfTransposer
2089                            ->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
2090                       (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2091                           sizeof(FIXP_DBL));
2092             FDKmemcpy(&ppQmfBufferOutImag_F[2 * j - offset + i]
2093                                            [hQmfTransposer->xOverQmf[0]],
2094                       &hQmfTransposer
2095                            ->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
2096                       (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2097                           sizeof(FIXP_DBL));
2098           }
2099         } else {
2100           for (i = 0; i < 2; i++) {
2101             FDKmemcpy(&ppQmfBufferOutReal_F[2 * j + i + ov_len]
2102                                            [hQmfTransposer->xOverQmf[0]],
2103                       &hQmfTransposer
2104                            ->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
2105                       (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2106                           sizeof(FIXP_DBL));
2107             FDKmemcpy(&ppQmfBufferOutImag_F[2 * j + i + ov_len]
2108                                            [hQmfTransposer->xOverQmf[0]],
2109                       &hQmfTransposer
2110                            ->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
2111                       (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2112                           sizeof(FIXP_DBL));
2113           }
2114         }
2115       }
2116     }
2117 
2118     /* move slots up */
2119     for (i = 0; i < HBE_MAX_OUT_SLOTS - 2; i++) {
2120       FDKmemcpy(
2121           &hQmfTransposer->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
2122           &hQmfTransposer->qmfHBEBufReal_F[i + 2][hQmfTransposer->xOverQmf[0]],
2123           (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2124               sizeof(FIXP_DBL));
2125       FDKmemcpy(
2126           &hQmfTransposer->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
2127           &hQmfTransposer->qmfHBEBufImag_F[i + 2][hQmfTransposer->xOverQmf[0]],
2128           (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2129               sizeof(FIXP_DBL));
2130     }
2131 
2132     /* finally set last two slot to zero */
2133     for (i = 0; i < 2; i++) {
2134       FDKmemset(&hQmfTransposer->qmfHBEBufReal_F[HBE_MAX_OUT_SLOTS - 1 - i]
2135                                                 [hQmfTransposer->xOverQmf[0]],
2136                 0,
2137                 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2138                     sizeof(FIXP_DBL));
2139       FDKmemset(&hQmfTransposer->qmfHBEBufImag_F[HBE_MAX_OUT_SLOTS - 1 - i]
2140                                                 [hQmfTransposer->xOverQmf[0]],
2141                 0,
2142                 (QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
2143                     sizeof(FIXP_DBL));
2144     }
2145   } /* qmfVocoderColsIn */
2146 
2147   if (keepStatesSyncedMode != KEEP_STATES_SYNCED_NOOUT) {
2148     if (keepStatesSyncedMode == KEEP_STATES_SYNCED_OUTDIFF) {
2149       for (i = 0; i < ov_len + LPC_ORDER; i++) {
2150         for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
2151              band++) {
2152           FIXP_DBL tmpR = ppQmfBufferOutReal_F[i][band];
2153           FIXP_DBL tmpI = ppQmfBufferOutImag_F[i][band];
2154 
2155           ppQmfBufferOutReal_F[i][band] =
2156               fMult(tmpR, cos_F[band]) -
2157               fMult(tmpI, (-cos_F[64 - band - 1])); /* sum should be <= 1
2158                                                        because of sin/cos
2159                                                        multiplication */
2160           ppQmfBufferOutImag_F[i][band] =
2161               fMult(tmpR, (-cos_F[64 - band - 1])) +
2162               fMult(tmpI, cos_F[band]); /* sum should by <= 1 because of sin/cos
2163                                            multiplication */
2164         }
2165       }
2166     } else {
2167       for (i = offset; i < hQmfTransposer->noCols; i++) {
2168         for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
2169              band++) {
2170           FIXP_DBL tmpR = ppQmfBufferOutReal_F[i + ov_len][band];
2171           FIXP_DBL tmpI = ppQmfBufferOutImag_F[i + ov_len][band];
2172 
2173           ppQmfBufferOutReal_F[i + ov_len][band] =
2174               fMult(tmpR, cos_F[band]) -
2175               fMult(tmpI, (-cos_F[64 - band - 1])); /* sum should be <= 1
2176                                                        because of sin/cos
2177                                                        multiplication */
2178           ppQmfBufferOutImag_F[i + ov_len][band] =
2179               fMult(tmpR, (-cos_F[64 - band - 1])) +
2180               fMult(tmpI, cos_F[band]); /* sum should by <= 1 because of sin/cos
2181                                            multiplication */
2182         }
2183       }
2184     }
2185   }
2186 
2187   *scale_hb = EXP2SCALE(scale_factor_hbe);
2188 }
2189 
GetxOverBandQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer)2190 int* GetxOverBandQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
2191   if (hQmfTransposer)
2192     return hQmfTransposer->xOverQmf;
2193   else
2194     return NULL;
2195 }
2196 
Get41SbrQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer)2197 int Get41SbrQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
2198   if (hQmfTransposer != NULL)
2199     return hQmfTransposer->bSbr41;
2200   else
2201     return 0;
2202 }
2203