Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <assert.h>
38 : #include <stdint.h>
39 : #include "options.h"
40 : #ifdef DEBUGGING
41 : #include "debug.h"
42 : #endif
43 : #include <math.h>
44 : #include "stat_dec.h"
45 : #include "prot.h"
46 : #include "rom_com.h"
47 : #include "wmc_auto.h"
48 :
49 : #if __STDC_VERSION__ >= 199901L
50 : #if defined __ICL
51 : #define restrict __restrict
52 : #endif
53 : #else
54 : #define restrict
55 : #endif
56 :
57 :
58 : /*-------------------------------------------------------------------*
59 : * Local prototypes
60 : *--------------------------------------------------------------------*/
61 :
62 : static void cldfb_init_proto_and_twiddles( HANDLE_CLDFB_FILTER_BANK hs );
63 :
64 : static float GetEnergyCldfb( float *energyValuesSum, float *energyLookahead, float **realValues, float **imagValues, const int16_t numberBands, int16_t numberCols, TEC_ENC_HANDLE hTecEnc );
65 :
66 : /*-------------------------------------------------------------------*
67 : * cplxMult()
68 : *
69 : * Conduct complex multiplication
70 : *--------------------------------------------------------------------*/
71 :
72 11546689632 : static void cplxMult(
73 : float *yr, /* o : real output */
74 : float *yi, /* o : imag output */
75 : const float xr, /* i : real input 1*/
76 : const float xi, /* i : imag input 1*/
77 : const float cr, /* i : real input 1*/
78 : const float ci /* i : imag input 1*/
79 : )
80 : {
81 11546689632 : *yr = xr * cr - xi * ci;
82 11546689632 : *yi = xr * ci + xi * cr;
83 :
84 11546689632 : return;
85 : }
86 :
87 :
88 : /*-------------------------------------------------------------------*
89 : * cldfbAnalysis()
90 : *
91 : * Conduct multiple overlap complex low delay MDCT
92 : *--------------------------------------------------------------------*/
93 :
94 12022610 : void cldfbAnalysis(
95 : const float *timeIn, /* i : time buffer */
96 : float **realBuffer, /* o : real value buffer */
97 : float **imagBuffer, /* o : imag value buffer */
98 : const int16_t samplesToProcess, /* i : samples to process */
99 : HANDLE_CLDFB_FILTER_BANK h_cldfb /* i : filterbank state */
100 : )
101 : {
102 : int16_t i, k;
103 : int16_t L2, M1, M2, M4;
104 12022610 : int16_t no_col = h_cldfb->no_col;
105 :
106 : float r1, r2, rr12, ir12;
107 : float i1, i2, ri12, ii12;
108 : float rBuffer[2 * CLDFB_NO_CHANNELS_MAX];
109 : float iBuffer[2 * CLDFB_NO_CHANNELS_MAX];
110 : const float *rot_vctr_re;
111 : const float *rot_vctr_im;
112 : const float *ptr_pf;
113 : float *timeBuffer, buffer[( CLDFB_NO_CHANNELS_MAX * CLDFB_NO_COL_MAX ) + ( 9 * CLDFB_NO_CHANNELS_MAX )];
114 : int16_t offset, frameSize;
115 :
116 12022610 : offset = h_cldfb->p_filter_length - h_cldfb->no_channels;
117 12022610 : frameSize = h_cldfb->no_channels * h_cldfb->no_col;
118 :
119 12022610 : assert( h_cldfb->prototype == CLDFB_PROTOTYPE_1_25MS );
120 : /* prepare input buffer */
121 12022610 : timeBuffer = buffer;
122 12022610 : mvr2r( h_cldfb->cldfb_state, timeBuffer, offset );
123 :
124 12022610 : if ( samplesToProcess > -1 )
125 : {
126 6077627 : mvr2r( timeIn, timeBuffer + offset, samplesToProcess );
127 6077627 : set_f( timeBuffer + offset + samplesToProcess, 0.0f, ( frameSize - samplesToProcess ) );
128 : }
129 : else
130 : {
131 5944983 : mvr2r( timeIn, timeBuffer + offset, frameSize );
132 : }
133 :
134 : /* only process needed cols */
135 12022610 : if ( samplesToProcess > -1 )
136 : {
137 6077627 : no_col = min( no_col, ( samplesToProcess + h_cldfb->no_channels - 1 ) / h_cldfb->no_channels );
138 : }
139 :
140 12022610 : M1 = h_cldfb->no_channels;
141 12022610 : M2 = M1 >> 1;
142 12022610 : M4 = M1 >> 2;
143 12022610 : L2 = M1 << 1;
144 :
145 12022610 : if ( M2 & 1 )
146 : {
147 7710 : M4 += 1;
148 : }
149 :
150 12022610 : rot_vctr_re = h_cldfb->rot_vec_ana_re;
151 12022610 : rot_vctr_im = h_cldfb->rot_vec_ana_im;
152 :
153 12022610 : ptr_pf = h_cldfb->p_filter;
154 :
155 192856864 : for ( i = 0; i < no_col; i++ )
156 : {
157 1624232138 : for ( k = 0; k < M4; k++ )
158 : {
159 : /* prototype filter */
160 1443397884 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
161 1443397884 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
162 1443397884 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
163 1443397884 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
164 1443397884 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
165 :
166 1443397884 : r2 = 0 - ptr_pf[( L2 - M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 0 * L2];
167 1443397884 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 1 * L2];
168 1443397884 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 2 * L2];
169 1443397884 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 3 * L2];
170 1443397884 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 4 * L2];
171 :
172 1443397884 : i1 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
173 1443397884 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
174 1443397884 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
175 1443397884 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
176 1443397884 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 4 * L2];
177 :
178 1443397884 : i2 = 0 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2];
179 1443397884 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2];
180 1443397884 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2];
181 1443397884 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2];
182 1443397884 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 4 * L2];
183 :
184 : /* folding + pre modulation of DST IV */
185 1443397884 : rr12 = r1 - r2;
186 1443397884 : ri12 = -i1 - i2;
187 1443397884 : cplxMult( &rBuffer[2 * k], &rBuffer[2 * k + 1], rr12, ri12, rot_vctr_re[k], rot_vctr_im[k] );
188 :
189 : /* folding + pre modulation of DCT IV */
190 1443397884 : ir12 = r1 + r2;
191 1443397884 : ii12 = i1 - i2;
192 1443397884 : cplxMult( &iBuffer[2 * k], &iBuffer[2 * k + 1], ir12, ii12, rot_vctr_re[k], rot_vctr_im[k] );
193 : }
194 :
195 1624108778 : for ( k = M4; k < M2; k++ )
196 : {
197 : /* prototype filter */
198 1443274524 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
199 1443274524 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
200 1443274524 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
201 1443274524 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
202 1443274524 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
203 :
204 1443274524 : r2 = 0 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 0 * L2];
205 1443274524 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 1 * L2];
206 1443274524 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 2 * L2];
207 1443274524 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 3 * L2];
208 1443274524 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 4 * L2];
209 :
210 1443274524 : i1 = 0 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 0 * L2];
211 1443274524 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 1 * L2];
212 1443274524 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 2 * L2];
213 1443274524 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 3 * L2];
214 1443274524 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 4 * L2];
215 :
216 1443274524 : i2 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
217 1443274524 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
218 1443274524 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
219 1443274524 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
220 1443274524 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 4 * L2];
221 :
222 : /* folding + pre modulation of DST IV */
223 1443274524 : rr12 = r1 + r2;
224 1443274524 : ri12 = i1 - i2;
225 1443274524 : cplxMult( &rBuffer[2 * k], &rBuffer[2 * k + 1], rr12, ri12, rot_vctr_re[k], rot_vctr_im[k] );
226 :
227 : /* folding + pre modulation of DCT IV */
228 1443274524 : ir12 = r1 - r2;
229 1443274524 : ii12 = i1 + i2;
230 1443274524 : cplxMult( &iBuffer[2 * k], &iBuffer[2 * k + 1], ir12, ii12, rot_vctr_re[k], rot_vctr_im[k] );
231 : }
232 :
233 : /* FFT of DST IV */
234 180834254 : fft_cldfb( rBuffer, M2 );
235 :
236 : /* post modulation of DST IV */
237 3067506662 : for ( k = 0; k < M2; k++ )
238 : {
239 2886672408 : cplxMult( &realBuffer[i][M1 - 1 - ( 2 * k )], &realBuffer[i][2 * k], rBuffer[2 * k], rBuffer[2 * k + 1], rot_vctr_re[k], rot_vctr_im[k] );
240 : }
241 :
242 : /* FFT of DCT IV */
243 180834254 : fft_cldfb( iBuffer, M2 );
244 :
245 : /* post modulation of DCT IV */
246 3067506662 : for ( k = 0; k < M2; k++ )
247 : {
248 : /* do it inplace */
249 2886672408 : cplxMult( &imagBuffer[i][2 * k], &imagBuffer[i][M1 - 1 - ( 2 * k )], iBuffer[2 * k], iBuffer[2 * k + 1], rot_vctr_re[k], rot_vctr_im[k] );
250 : }
251 :
252 180834254 : timeBuffer += L2 * 5;
253 180834254 : timeBuffer += h_cldfb->no_channels - h_cldfb->p_filter_length;
254 : }
255 :
256 : /* update memory */
257 12022610 : mvr2r( buffer + frameSize, h_cldfb->cldfb_state, offset );
258 :
259 12022610 : return;
260 : }
261 :
262 : /*-------------------------------------------------------------------*
263 : * cldfbAnalysis_ts()
264 : *
265 : *
266 : *--------------------------------------------------------------------*/
267 :
268 567706716 : void cldfbAnalysis_ts(
269 : const float *timeIn, /* i : time buffer */
270 : float realBuffer[CLDFB_NO_CHANNELS_MAX], /* o : real value buffer */
271 : float imagBuffer[CLDFB_NO_CHANNELS_MAX], /* o : imag value buffer */
272 : const int16_t samplesToProcess, /* i : samples to process */
273 : HANDLE_CLDFB_FILTER_BANK h_cldfb /* i : filterbank state */
274 : )
275 : {
276 : int16_t i, k;
277 : int16_t L2, M1, M2, M4;
278 567706716 : int16_t no_col = h_cldfb->no_col;
279 :
280 : float r1, r2, rr12, ir12;
281 : float i1, i2, ri12, ii12;
282 : float rBuffer[2 * CLDFB_NO_CHANNELS_MAX];
283 : float iBuffer[2 * CLDFB_NO_CHANNELS_MAX];
284 : const float *rot_vctr_re;
285 : const float *rot_vctr_im;
286 : const float *rot_vctr_delay_re;
287 : const float *rot_vctr_delay_im;
288 : const float *ptr_pf;
289 : float *timeBuffer, buffer[( CLDFB_NO_CHANNELS_MAX * CLDFB_NO_COL_MAX ) + ( 9 * CLDFB_NO_CHANNELS_MAX )];
290 : int16_t offset, frameSize;
291 :
292 567706716 : offset = h_cldfb->p_filter_length - h_cldfb->no_channels;
293 567706716 : frameSize = h_cldfb->no_channels * h_cldfb->no_col;
294 :
295 : /* prepare input buffer */
296 567706716 : timeBuffer = buffer;
297 567706716 : mvr2r( h_cldfb->cldfb_state, timeBuffer, offset );
298 :
299 567706716 : if ( samplesToProcess > -1 )
300 : {
301 567706716 : mvr2r( timeIn, timeBuffer + offset, samplesToProcess );
302 567706716 : set_f( timeBuffer + offset + samplesToProcess, 0.0f, ( frameSize - samplesToProcess ) );
303 : }
304 : else
305 : {
306 0 : mvr2r( timeIn, timeBuffer + offset, frameSize );
307 : }
308 :
309 : /* only process needed cols */
310 567706716 : if ( samplesToProcess > -1 )
311 : {
312 567706716 : no_col = min( no_col, ( samplesToProcess + h_cldfb->no_channels - 1 ) / h_cldfb->no_channels );
313 567706716 : assert( no_col == 1 );
314 : }
315 :
316 567706716 : M1 = h_cldfb->no_channels;
317 567706716 : M2 = M1 >> 1;
318 567706716 : M4 = M1 >> 2;
319 567706716 : L2 = M1 << 1;
320 :
321 567706716 : if ( M2 & 1 )
322 : {
323 0 : M4 += 1;
324 : }
325 :
326 567706716 : rot_vctr_re = h_cldfb->rot_vec_ana_re;
327 567706716 : rot_vctr_im = h_cldfb->rot_vec_ana_im;
328 567706716 : rot_vctr_delay_re = h_cldfb->rot_vec_ana_delay_re;
329 567706716 : rot_vctr_delay_im = h_cldfb->rot_vec_ana_delay_im;
330 :
331 567706716 : ptr_pf = h_cldfb->p_filter;
332 :
333 1135413432 : for ( i = 0; i < no_col; i++ )
334 : {
335 7023996444 : for ( k = 0; k < M4; k++ )
336 : {
337 : /* prototype filter */
338 6456289728 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
339 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
340 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
341 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
342 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
343 :
344 6456289728 : r2 = 0 - ptr_pf[( L2 - M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 0 * L2];
345 6456289728 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 1 * L2];
346 6456289728 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 2 * L2];
347 6456289728 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 3 * L2];
348 6456289728 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 4 * L2];
349 :
350 6456289728 : i1 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
351 6456289728 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
352 6456289728 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
353 6456289728 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
354 6456289728 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 4 * L2];
355 :
356 6456289728 : i2 = 0 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2];
357 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2];
358 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2];
359 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2];
360 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 4 * L2];
361 :
362 : /* folding + pre modulation of DST IV */
363 6456289728 : rr12 = r1 - r2;
364 6456289728 : ri12 = -i1 - i2;
365 : /*cplxMult(&rBuffer[2*k],&rBuffer[2*k+1],rr12,ri12,rot_vctr_re[k],rot_vctr_im[k]);*/
366 6456289728 : rBuffer[2 * k] = rr12 * rot_vctr_re[k] - ri12 * rot_vctr_im[k];
367 6456289728 : rBuffer[2 * k + 1] = rr12 * rot_vctr_im[k] + ri12 * rot_vctr_re[k];
368 :
369 : /* folding + pre modulation of DCT IV */
370 6456289728 : ir12 = r1 + r2;
371 6456289728 : ii12 = i1 - i2;
372 : /*cplxMult(&iBuffer[2*k],&iBuffer[2*k+1],ir12,ii12,rot_vctr_re[k],rot_vctr_im[k]);*/
373 6456289728 : iBuffer[2 * k] = ir12 * rot_vctr_re[k] - ii12 * rot_vctr_im[k];
374 6456289728 : iBuffer[2 * k + 1] = ir12 * rot_vctr_im[k] + ii12 * rot_vctr_re[k];
375 : }
376 :
377 7023996444 : for ( k = M4; k < M2; k++ )
378 : {
379 : /* prototype filter */
380 6456289728 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
381 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
382 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
383 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
384 6456289728 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
385 :
386 6456289728 : r2 = 0 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 0 * L2];
387 6456289728 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 1 * L2];
388 6456289728 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 2 * L2];
389 6456289728 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 3 * L2];
390 6456289728 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 4 * L2];
391 :
392 6456289728 : i1 = 0 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 0 * L2];
393 6456289728 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 1 * L2];
394 6456289728 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 2 * L2];
395 6456289728 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 3 * L2];
396 6456289728 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 4 * L2];
397 :
398 6456289728 : i2 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
399 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
400 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
401 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
402 6456289728 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 4 * L2];
403 :
404 : /* folding + pre modulation of DST IV */
405 6456289728 : rr12 = r1 + r2;
406 6456289728 : ri12 = i1 - i2;
407 : /*cplxMult(&rBuffer[2*k],&rBuffer[2*k+1],rr12,ri12,rot_vctr_re[k],rot_vctr_im[k]);*/
408 6456289728 : rBuffer[2 * k] = rr12 * rot_vctr_re[k] - ri12 * rot_vctr_im[k];
409 6456289728 : rBuffer[2 * k + 1] = rr12 * rot_vctr_im[k] + ri12 * rot_vctr_re[k];
410 :
411 : /* folding + pre modulation of DCT IV */
412 6456289728 : ir12 = r1 - r2;
413 6456289728 : ii12 = i1 + i2;
414 : /*cplxMult(&iBuffer[2*k],&iBuffer[2*k+1],ir12,ii12,rot_vctr_re[k],rot_vctr_im[k]);*/
415 6456289728 : iBuffer[2 * k] = ir12 * rot_vctr_re[k] - ii12 * rot_vctr_im[k];
416 6456289728 : iBuffer[2 * k + 1] = ir12 * rot_vctr_im[k] + ii12 * rot_vctr_re[k];
417 : }
418 :
419 : /* FFT of DST IV */
420 567706716 : fft_cldfb( rBuffer, M2 );
421 :
422 : /* post modulation of DST IV */
423 13480286172 : for ( k = 0; k < M2; k++ )
424 : {
425 : /*cplxMult(&realBuffer[M1-1-(2*k)],&realBuffer[2*k],rBuffer[2*k],rBuffer[2*k+1],rot_vctr_re[k],rot_vctr_im[k]);*/
426 12912579456 : realBuffer[M1 - 1 - ( 2 * k )] = rBuffer[2 * k] * rot_vctr_re[k] - rBuffer[2 * k + 1] * rot_vctr_im[k];
427 12912579456 : realBuffer[2 * k] = rBuffer[2 * k] * rot_vctr_im[k] + rBuffer[2 * k + 1] * rot_vctr_re[k];
428 : }
429 :
430 : /* FFT of DCT IV */
431 567706716 : fft_cldfb( iBuffer, M2 );
432 :
433 : /* post modulation of DCT IV */
434 13480286172 : for ( k = 0; k < M2; k++ )
435 : {
436 : /* do it inplace */
437 : /*cplxMult(&imagBuffer[2*k],&imagBuffer[M1-1-(2*k)],iBuffer[2*k],iBuffer[2*k+1],rot_vctr_re[k],rot_vctr_im[k]);*/
438 12912579456 : imagBuffer[2 * k] = iBuffer[2 * k] * rot_vctr_re[k] - iBuffer[2 * k + 1] * rot_vctr_im[k];
439 12912579456 : imagBuffer[M1 - 1 - ( 2 * k )] = iBuffer[2 * k] * rot_vctr_im[k] + iBuffer[2 * k + 1] * rot_vctr_re[k];
440 : }
441 :
442 567706716 : if ( h_cldfb->prototype == CLDFB_PROTOTYPE_5_00MS )
443 : {
444 : /* rotation due to delay*/
445 : /*if(h_cldfb->da != M1)*/
446 567706716 : if ( rot_vctr_delay_re != NULL )
447 : {
448 26392865628 : for ( k = 0; k < M1; k++ )
449 : {
450 : float cplx_aux;
451 : /* delay */
452 : /*cplxMult(&rBuffer[k], &iBuffer[k], realBuffer[i][k], imagBuffer[i][k], cos((EVS_PI/M1)*(k+0.5)*((h_cldfb->da-M1)*0.5)),
453 : sin((EVS_PI/M1)*(k+0.5)*((h_cldfb->da-M1)*0.5)));*/
454 : /*cplxMult(&rBuffer[k], &iBuffer[k], realBuffer[k], imagBuffer[k], rot_vctr_delay_re[k], rot_vctr_delay_im[k]);*/
455 : /*cplxMult(&realBuffer[k], &imagBuffer[k], realBuffer[k], imagBuffer[k], rot_vctr_delay_re[k], rot_vctr_delay_im[k]);*/
456 : /*realBuffer[k] = rBuffer[k];
457 : imagBuffer[k] = iBuffer[k];*/
458 25825158912 : cplx_aux = realBuffer[k] * rot_vctr_delay_re[k] - imagBuffer[k] * rot_vctr_delay_im[k];
459 25825158912 : imagBuffer[k] = realBuffer[k] * rot_vctr_delay_im[k] + imagBuffer[k] * rot_vctr_delay_re[k];
460 25825158912 : realBuffer[k] = cplx_aux;
461 : }
462 : }
463 : }
464 :
465 567706716 : timeBuffer += L2 * 5;
466 567706716 : timeBuffer += h_cldfb->no_channels - h_cldfb->p_filter_length;
467 : }
468 :
469 : /* update memory */
470 567706716 : if ( samplesToProcess > -1 )
471 : {
472 567706716 : mvr2r( buffer + samplesToProcess, h_cldfb->cldfb_state, offset );
473 : }
474 : else
475 : {
476 0 : mvr2r( buffer + frameSize, h_cldfb->cldfb_state, offset );
477 : }
478 :
479 567706716 : return;
480 : }
481 :
482 : /*-------------------------------------------------------------------*
483 : * cldfbSynthesis()
484 : *
485 : * Conduct inverse multple overlap cmplex low delay MDCT
486 : *--------------------------------------------------------------------*/
487 :
488 584630439 : void cldfbSynthesis(
489 : float **realBuffer, /* i : real values */
490 : float **imagBuffer, /* i : imag values */
491 : float *timeOut, /* o : output time domain samples */
492 : const int16_t samplesToProcess, /* i : number of processed samples */
493 : HANDLE_CLDFB_FILTER_BANK h_cldfb /* i : filter bank state */
494 : )
495 : {
496 : int16_t i;
497 : int16_t k;
498 : int16_t L2;
499 : int16_t M1;
500 : int16_t M2;
501 : int16_t M41;
502 : int16_t M42;
503 : int16_t Mz;
504 :
505 : float rBuffer[2 * CLDFB_NO_CHANNELS_MAX];
506 : float iBuffer[2 * CLDFB_NO_CHANNELS_MAX];
507 : const float *rot_vctr_re;
508 : const float *rot_vctr_im;
509 : const float *rot_vctr_delay_re;
510 : const float *rot_vctr_delay_im;
511 : float rr12, ir12;
512 : float ri12, ii12;
513 :
514 : float *synthesisBuffer, buffer[( CLDFB_NO_CHANNELS_MAX * CLDFB_NO_COL_MAX ) + ( 10 * CLDFB_NO_CHANNELS_MAX )];
515 : float new_samples[2 * CLDFB_NO_CHANNELS_MAX];
516 :
517 : float *ptr_time_out;
518 : const float *p_filter;
519 :
520 : float accu0, accu1, accu2, accu3, accu4;
521 584630439 : int16_t no_col = h_cldfb->no_col;
522 :
523 584630439 : M1 = h_cldfb->no_channels;
524 584630439 : L2 = M1 << 1;
525 584630439 : M2 = M1 >> 1;
526 584630439 : M41 = M2 >> 1;
527 584630439 : M42 = M2 - M41;
528 584630439 : Mz = M1 - h_cldfb->bandsToZero;
529 :
530 : /* only process needed cols */
531 584630439 : if ( samplesToProcess > -1 )
532 : {
533 580319176 : no_col = min( no_col, ( samplesToProcess + h_cldfb->no_channels - 1 ) / h_cldfb->no_channels );
534 : }
535 :
536 584630439 : rot_vctr_re = h_cldfb->rot_vec_syn_re;
537 584630439 : rot_vctr_im = h_cldfb->rot_vec_syn_im;
538 :
539 584630439 : rot_vctr_delay_re = h_cldfb->rot_vec_syn_delay_re;
540 584630439 : rot_vctr_delay_im = h_cldfb->rot_vec_syn_delay_im;
541 :
542 584630439 : synthesisBuffer = buffer;
543 584630439 : mvr2r( h_cldfb->cldfb_state, synthesisBuffer + ( M1 * no_col ), h_cldfb->p_filter_length );
544 :
545 584630439 : p_filter = h_cldfb->p_filter;
546 584630439 : ptr_time_out = timeOut;
547 :
548 : /*synthesisBuffer += M1 * h_cldfb->no_col;*/
549 584630439 : synthesisBuffer += M1 * no_col;
550 :
551 1354009697 : for ( k = 0; k < no_col; k++ )
552 : {
553 769379258 : if ( h_cldfb->prototype == CLDFB_PROTOTYPE_5_00MS )
554 : {
555 : /* rotation due to delay*/
556 : /*if(h_cldfb->ds != M1)*/
557 692276288 : if ( rot_vctr_delay_re != NULL )
558 : {
559 31754698588 : for ( i = 0; i < M1; i++ )
560 : {
561 : float cplx_aux;
562 : /* delay */
563 : /*cplxMult(&rBuffer[i], &iBuffer[i], realBuffer[k][i], imagBuffer[k][i], cos((EVS_PI/M1)*(i+0.5)*(-(h_cldfb->ds-M1)*0.5)),
564 : sin((EVS_PI/M1)*(i+0.5)*(-(h_cldfb->ds-M1)*0.5)));*/
565 : /*cplxMult(&rBuffer[i], &iBuffer[i], realBuffer[k][i], imagBuffer[k][i], rot_vctr_delay_re[i], rot_vctr_delay_im[i]);*/
566 : /*cplxMult(&realBuffer[k][i], &imagBuffer[k][i], realBuffer[k][i], imagBuffer[k][i], rot_vctr_delay_re[i], rot_vctr_delay_im[i]);*/
567 31062422300 : cplx_aux = realBuffer[k][i] * rot_vctr_delay_re[i] - imagBuffer[k][i] * rot_vctr_delay_im[i];
568 31062422300 : imagBuffer[k][i] = realBuffer[k][i] * rot_vctr_delay_im[i] + imagBuffer[k][i] * rot_vctr_delay_re[i];
569 31062422300 : realBuffer[k][i] = cplx_aux;
570 : /*realBuffer[k][i] = rBuffer[i];
571 : imagBuffer[k][i] = iBuffer[i];*/
572 : }
573 : }
574 : }
575 2243515550 : for ( i = Mz; i < M1; i++ )
576 : {
577 1474136292 : realBuffer[k][i] = 0.0f;
578 1474136292 : imagBuffer[k][i] = 0.0f;
579 : }
580 :
581 17800078298 : for ( i = 0; i < M2; i++ )
582 : {
583 : /* pre modulation of DST IV */
584 : /*cplxMult(&rBuffer[2*i], &rBuffer[2*i+1], realBuffer[k][2*i], realBuffer[k][M1-1-2*i], rot_vctr_re[i], rot_vctr_im[i]);*/
585 17030699040 : rBuffer[2 * i] = realBuffer[k][2 * i] * rot_vctr_re[i] - realBuffer[k][M1 - 1 - 2 * i] * rot_vctr_im[i];
586 17030699040 : rBuffer[2 * i + 1] = realBuffer[k][2 * i] * rot_vctr_im[i] + realBuffer[k][M1 - 1 - 2 * i] * rot_vctr_re[i];
587 :
588 : /* pre modulation of DCT IV */
589 : /*cplxMult(&iBuffer[2*i], &iBuffer[2*i+1],-imagBuffer[k][2*i], imagBuffer[k][M1-1-2*i], rot_vctr_re[i], rot_vctr_im[i]);*/
590 17030699040 : iBuffer[2 * i] = ( -( imagBuffer[k][2 * i] ) ) * rot_vctr_re[i] - imagBuffer[k][M1 - 1 - 2 * i] * rot_vctr_im[i];
591 17030699040 : iBuffer[2 * i + 1] = ( -( imagBuffer[k][2 * i] ) ) * rot_vctr_im[i] + imagBuffer[k][M1 - 1 - 2 * i] * rot_vctr_re[i];
592 : }
593 :
594 : /* FFT of DST IV */
595 769379258 : fft_cldfb( rBuffer, M2 );
596 :
597 : /* FFT of DCT IV */
598 769379258 : fft_cldfb( iBuffer, M2 );
599 :
600 : /* folding */
601 9284657139 : for ( i = 0; i < M41; i++ )
602 : {
603 : /* post modulation of DST IV */
604 8515277881 : rr12 = rBuffer[M1 - 2 - 2 * i] * rot_vctr_re[M2 - 1 - i] - rBuffer[M1 - 1 - 2 * i] * rot_vctr_im[M2 - 1 - i];
605 8515277881 : ri12 = rBuffer[M1 - 2 - 2 * i] * rot_vctr_im[M2 - 1 - i] + rBuffer[M1 - 1 - 2 * i] * rot_vctr_re[M2 - 1 - i];
606 :
607 : /* post modulation of DCT IV */
608 8515277881 : ir12 = iBuffer[M1 - 2 - 2 * i] * rot_vctr_re[M2 - 1 - i] - iBuffer[M1 - 1 - 2 * i] * rot_vctr_im[M2 - 1 - i];
609 8515277881 : ii12 = iBuffer[M1 - 2 - 2 * i] * rot_vctr_im[M2 - 1 - i] + iBuffer[M1 - 1 - 2 * i] * rot_vctr_re[M2 - 1 - i];
610 :
611 8515277881 : new_samples[M1 + M2 + 1 + 2 * i] = -rr12 - ii12;
612 8515277881 : new_samples[M2 - 2 - 2 * i] = -ri12 - ir12;
613 :
614 8515277881 : new_samples[M1 + M2 - 2 - 2 * i] = rr12 - ii12;
615 8515277881 : new_samples[M2 + 1 + 2 * i] = ir12 - ri12;
616 : }
617 :
618 9284800417 : for ( i = 0; i < M42; i++ )
619 : {
620 : /* post modulation of DST IV */
621 8515421159 : rr12 = rBuffer[2 * i] * rot_vctr_re[i] - rBuffer[2 * i + 1] * rot_vctr_im[i];
622 8515421159 : ri12 = rBuffer[2 * i] * rot_vctr_im[i] + rBuffer[2 * i + 1] * rot_vctr_re[i];
623 :
624 : /* post modulation of DCT IV */
625 8515421159 : ir12 = iBuffer[2 * i] * rot_vctr_re[i] - iBuffer[2 * i + 1] * rot_vctr_im[i];
626 8515421159 : ii12 = iBuffer[2 * i] * rot_vctr_im[i] + iBuffer[2 * i + 1] * rot_vctr_re[i];
627 :
628 8515421159 : new_samples[M1 + M2 + 2 * i] = ri12 + ir12;
629 8515421159 : new_samples[M2 - 1 - 2 * i] = rr12 + ii12;
630 :
631 8515421159 : new_samples[M1 + M2 - 1 - 2 * i] = ir12 - ri12;
632 8515421159 : new_samples[M2 + 2 * i] = rr12 - ii12;
633 : }
634 :
635 : /* synthesis prototype filter */
636 68892175418 : for ( i = 0; i < L2; i++ )
637 : {
638 68122796160 : accu0 = synthesisBuffer[0 * L2 + i] + p_filter[( 0 * L2 + i )] * new_samples[L2 - 1 - i];
639 68122796160 : accu1 = synthesisBuffer[1 * L2 + i] + p_filter[( 1 * L2 + i )] * new_samples[L2 - 1 - i];
640 68122796160 : accu2 = synthesisBuffer[2 * L2 + i] + p_filter[( 2 * L2 + i )] * new_samples[L2 - 1 - i];
641 68122796160 : accu3 = synthesisBuffer[3 * L2 + i] + p_filter[( 3 * L2 + i )] * new_samples[L2 - 1 - i];
642 68122796160 : accu4 = synthesisBuffer[4 * L2 + i] + p_filter[( 4 * L2 + i )] * new_samples[L2 - 1 - i];
643 :
644 68122796160 : synthesisBuffer[0 * L2 + i] = accu0;
645 68122796160 : synthesisBuffer[1 * L2 + i] = accu1;
646 68122796160 : synthesisBuffer[2 * L2 + i] = accu2;
647 68122796160 : synthesisBuffer[3 * L2 + i] = accu3;
648 68122796160 : synthesisBuffer[4 * L2 + i] = accu4;
649 : }
650 :
651 34830777338 : for ( i = 0; i < M1; i++ )
652 : {
653 34061398080 : ptr_time_out[M1 - 1 - i] = synthesisBuffer[4 * L2 + M1 + i];
654 : }
655 :
656 769379258 : ptr_time_out += M1;
657 :
658 769379258 : synthesisBuffer -= M1;
659 :
660 769379258 : set_f( synthesisBuffer, 0, M1 );
661 : }
662 :
663 : /* update memory */
664 584630439 : mvr2r( buffer, h_cldfb->cldfb_state, h_cldfb->p_filter_length );
665 :
666 584630439 : return;
667 : }
668 :
669 : /*-------------------------------------------------------------------*
670 : * configureClfdb()
671 : *
672 : * configures a CLDFB handle
673 : *--------------------------------------------------------------------*/
674 :
675 2561548 : void configureCldfb(
676 : HANDLE_CLDFB_FILTER_BANK h_cldfb, /* i/o: filter bank handle */
677 : const int32_t sampling_rate /* i : sampling rate */
678 : )
679 : {
680 :
681 2561548 : h_cldfb->no_col = CLDFB_NO_COL_MAX;
682 2561548 : h_cldfb->bandsToZero = 0;
683 2561548 : h_cldfb->nab = 0;
684 :
685 2561548 : h_cldfb->no_channels = (int16_t) ( sampling_rate * INV_CLDFB_BANDWIDTH + 0.5f );
686 2561548 : h_cldfb->p_filter_length = 10 * h_cldfb->no_channels;
687 :
688 2561548 : cldfb_init_proto_and_twiddles( h_cldfb );
689 :
690 2561548 : return;
691 : }
692 :
693 : /*-------------------------------------------------------------------*
694 : * openClfdb()
695 : *
696 : * open and configures a CLDFB handle
697 : *--------------------------------------------------------------------*/
698 :
699 1841631 : ivas_error openCldfb(
700 : HANDLE_CLDFB_FILTER_BANK *h_cldfb, /* i/o: filter bank handle */
701 : CLDFB_TYPE type, /* i : analysis or synthesis */
702 : const int32_t sampling_rate, /* i : sampling rate */
703 : CLDFB_PROTOTYPE prototype /* i : CLDFB version (1.25ms/5ms delay) */
704 : )
705 : {
706 : HANDLE_CLDFB_FILTER_BANK hs;
707 : int16_t buf_len;
708 :
709 1841631 : if ( ( hs = (HANDLE_CLDFB_FILTER_BANK) malloc( sizeof( CLDFB_FILTER_BANK ) ) ) == NULL )
710 : {
711 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for CLDFB" );
712 : }
713 :
714 1841631 : hs->type = type;
715 1841631 : hs->prototype = prototype;
716 :
717 1841631 : configureCldfb( hs, sampling_rate );
718 1841631 : hs->memory = NULL;
719 1841631 : hs->memory_length = 0;
720 :
721 1841631 : if ( type == CLDFB_ANALYSIS )
722 : {
723 746357 : buf_len = hs->p_filter_length - hs->no_channels;
724 : }
725 : else
726 : {
727 1095274 : buf_len = hs->p_filter_length;
728 : }
729 :
730 1841631 : if ( ( hs->cldfb_state = (float *) malloc( buf_len * sizeof( float ) ) ) == NULL )
731 : {
732 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for CLDFB" );
733 : }
734 :
735 1841631 : set_f( hs->cldfb_state, 0.0f, buf_len );
736 :
737 1841631 : *h_cldfb = hs;
738 :
739 1841631 : return IVAS_ERR_OK;
740 : }
741 :
742 :
743 : /*-------------------------------------------------------------------*
744 : * resampleCldfb()
745 : *
746 : * Change sample rate of filter bank
747 : *--------------------------------------------------------------------*/
748 :
749 507445 : void resampleCldfb(
750 : HANDLE_CLDFB_FILTER_BANK hs, /* i/o: filter bank handle */
751 : const int32_t newSamplerate )
752 : {
753 : int16_t timeOffset;
754 :
755 : /* keep old parameters before switching*/
756 507445 : int16_t timeOffsetold = hs->p_filter_length - hs->no_channels;
757 :
758 : /* new settings */
759 507445 : configureCldfb( hs, newSamplerate );
760 507445 : timeOffset = hs->p_filter_length - hs->no_channels;
761 :
762 : /*low complexity-resampling only stored previous samples that are needed for next frame modulation */
763 507445 : lerp( hs->cldfb_state, hs->cldfb_state, timeOffset, timeOffsetold );
764 :
765 507445 : return;
766 : }
767 :
768 : /*-------------------------------------------------------------------*
769 : * analysisCLDFBEncoder()
770 : *
771 : * Encoder CLDFB analysis + energy stage
772 : *--------------------------------------------------------------------*/
773 :
774 4492243 : void analysisCldfbEncoder(
775 : Encoder_State *st, /* i/o: encoder state structure */
776 : const float *timeIn,
777 : const int16_t samplesToProcess,
778 : float realBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
779 : float imagBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
780 : float *ppBuf_Ener )
781 : {
782 : int16_t i;
783 : float *ppBuf_Real[CLDFB_NO_COL_MAX];
784 : float *ppBuf_Imag[CLDFB_NO_COL_MAX];
785 :
786 76368131 : for ( i = 0; i < CLDFB_NO_COL_MAX; i++ )
787 : {
788 71875888 : ppBuf_Real[i] = &realBuffer[i][0];
789 71875888 : ppBuf_Imag[i] = &imagBuffer[i][0];
790 : }
791 :
792 4492243 : cldfbAnalysis( timeIn, ppBuf_Real, ppBuf_Imag, samplesToProcess, st->cldfbAnaEnc );
793 :
794 4492243 : st->currEnergyHF = GetEnergyCldfb( ppBuf_Ener, &st->currEnergyLookAhead, ppBuf_Real, ppBuf_Imag, st->cldfbAnaEnc->no_channels, st->cldfbAnaEnc->no_col, st->hTECEnc );
795 :
796 4492243 : return;
797 : }
798 :
799 : /*-------------------------------------------------------------------*
800 : * GetEnergyCldfb()
801 : *
802 : * Conduct energy from complex data
803 : *--------------------------------------------------------------------*/
804 :
805 4492243 : static float GetEnergyCldfb(
806 : float *energyValuesSum, /* o : the result of the operation */
807 : float *energyLookahead, /* o : the result in the core look-ahead slot */
808 : float **realValues, /* i : the real part of the subsamples */
809 : float **imagValues, /* i : the imaginary part of the subsamples */
810 : const int16_t numberBands, /* i : number of bands */
811 : int16_t numberCols, /* i : number of subsamples */
812 : TEC_ENC_HANDLE hTecEnc /* i/o: TEC handle */
813 : )
814 : {
815 : int16_t j, k;
816 : float energyValues[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
817 4492243 : int16_t numLookahead = 1;
818 :
819 76368131 : for ( k = 0; k < numberCols; k++ )
820 : {
821 3891678768 : for ( j = 0; j < numberBands; j++ )
822 : {
823 3819802880 : energyValues[k][j] = realValues[k][j] * realValues[k][j] +
824 3819802880 : imagValues[k][j] * imagValues[k][j];
825 : }
826 : }
827 :
828 4492243 : if ( numberBands >= freqTable[1] && hTecEnc != NULL )
829 : {
830 : float *tempEnergyValuesArry[CLDFB_NO_COL_MAX];
831 :
832 67418 : assert( numberCols == CLDFB_NO_COL_MAX );
833 1146106 : for ( j = 0; j < numberCols; j++ )
834 : {
835 1078688 : tempEnergyValuesArry[j] = &energyValues[j][0];
836 : }
837 :
838 67418 : calcHiEnvLoBuff( numberCols, freqTable, 1, tempEnergyValuesArry, hTecEnc->loBuffer, hTecEnc->hiTempEnv );
839 : }
840 :
841 243229923 : for ( j = 0; j < numberBands; j++ )
842 : {
843 238737680 : energyValuesSum[j] = 0;
844 4058540560 : for ( k = 0; k < CLDFB_NO_COL_MAX; k++ )
845 : {
846 3819802880 : energyValuesSum[j] += energyValues[k][j];
847 : }
848 : }
849 :
850 4492243 : if ( numberBands > 20 )
851 : {
852 4115463 : float energyHF = *energyLookahead; /* energy above 8 kHz */
853 4115463 : numberCols -= numLookahead;
854 4115463 : *energyLookahead = 6.1e-5f; /* process look-ahead region */
855 :
856 86424723 : for ( j = 20; j < min( 40, numberBands ); j++ )
857 : {
858 82309260 : energyHF += energyValuesSum[j];
859 :
860 164618520 : for ( k = numberCols; k < CLDFB_NO_COL_MAX; k++ )
861 : {
862 82309260 : energyHF -= energyValues[k][j];
863 82309260 : *energyLookahead += energyValues[k][j];
864 : }
865 : }
866 :
867 4115463 : return energyHF * OUTMAX_SQ_INV;
868 : }
869 :
870 376780 : return 65535.0f;
871 : }
872 :
873 :
874 : /*-------------------------------------------------------------------*
875 : * GetEnergyCldfb()
876 : *
877 : * Remove handle
878 : *--------------------------------------------------------------------*/
879 :
880 2989149 : void deleteCldfb(
881 : HANDLE_CLDFB_FILTER_BANK *h_cldfb /* i/o: filter bank handle */
882 : )
883 : {
884 2989149 : HANDLE_CLDFB_FILTER_BANK hs = *h_cldfb;
885 :
886 2989149 : if ( h_cldfb == NULL || *h_cldfb == NULL )
887 : {
888 1147518 : return;
889 : }
890 :
891 1841631 : if ( hs->cldfb_state )
892 : {
893 1841631 : free( hs->cldfb_state );
894 : }
895 :
896 1841631 : free( hs );
897 1841631 : *h_cldfb = NULL;
898 :
899 1841631 : return;
900 : }
901 :
902 :
903 : /*-------------------------------------------------------------------*
904 : * cldfb_init_proto_and_twiddles()
905 : *
906 : * Initializes rom pointer
907 : *--------------------------------------------------------------------*/
908 :
909 2561548 : static void cldfb_init_proto_and_twiddles(
910 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
911 : )
912 : {
913 : /*find appropriate set of rotVecs*/
914 2561548 : switch ( hs->no_channels )
915 : {
916 63 : case 10:
917 63 : hs->rot_vec_ana_re = rot_vec_ana_re_L10;
918 63 : hs->rot_vec_ana_im = rot_vec_ana_im_L10;
919 63 : hs->rot_vec_syn_re = rot_vec_syn_re_L10;
920 63 : hs->rot_vec_syn_im = rot_vec_syn_im_L10;
921 :
922 63 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
923 : {
924 63 : hs->p_filter = CLDFB80_10;
925 63 : hs->scale = CLDFB80_10_SCALE;
926 63 : hs->ds = 10;
927 63 : hs->da = 10;
928 63 : hs->rot_vec_ana_delay_re = NULL;
929 63 : hs->rot_vec_ana_delay_im = NULL;
930 63 : hs->rot_vec_syn_delay_re = NULL;
931 63 : hs->rot_vec_syn_delay_im = NULL;
932 : }
933 0 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
934 : {
935 0 : hs->p_filter = LDQMF_10;
936 0 : hs->scale = LDQMF_10_SCALE;
937 0 : hs->ds = 40;
938 0 : hs->da = -20;
939 0 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
940 0 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
941 0 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
942 0 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
943 : }
944 63 : break;
945 :
946 361415 : case 16:
947 361415 : hs->rot_vec_ana_re = rot_vec_ana_re_L16;
948 361415 : hs->rot_vec_ana_im = rot_vec_ana_im_L16;
949 361415 : hs->rot_vec_syn_re = rot_vec_syn_re_L16;
950 361415 : hs->rot_vec_syn_im = rot_vec_syn_im_L16;
951 361415 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
952 : {
953 356406 : hs->p_filter = CLDFB80_16;
954 356406 : hs->scale = CLDFB80_16_SCALE;
955 356406 : hs->ds = 20;
956 356406 : hs->da = 20;
957 356406 : hs->rot_vec_ana_delay_re = NULL;
958 356406 : hs->rot_vec_ana_delay_im = NULL;
959 356406 : hs->rot_vec_syn_delay_re = NULL;
960 356406 : hs->rot_vec_syn_delay_im = NULL;
961 : }
962 5009 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
963 : {
964 5009 : hs->p_filter = LDQMF_16;
965 5009 : hs->scale = LDQMF_16_SCALE;
966 5009 : hs->ds = 80;
967 5009 : hs->da = -40;
968 5009 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
969 5009 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
970 5009 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
971 5009 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
972 : }
973 361415 : break;
974 :
975 881846 : case 20:
976 881846 : hs->rot_vec_ana_re = rot_vec_ana_re_L20;
977 881846 : hs->rot_vec_ana_im = rot_vec_ana_im_L20;
978 881846 : hs->rot_vec_syn_re = rot_vec_syn_re_L20;
979 881846 : hs->rot_vec_syn_im = rot_vec_syn_im_L20;
980 881846 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
981 : {
982 606685 : hs->p_filter = CLDFB80_20;
983 606685 : hs->scale = CLDFB80_20_SCALE;
984 606685 : hs->ds = 20;
985 606685 : hs->da = 20;
986 606685 : hs->rot_vec_ana_delay_re = NULL;
987 606685 : hs->rot_vec_ana_delay_im = NULL;
988 606685 : hs->rot_vec_syn_delay_re = NULL;
989 606685 : hs->rot_vec_syn_delay_im = NULL;
990 : }
991 275161 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
992 : {
993 275161 : hs->p_filter = LDQMF_20;
994 275161 : hs->scale = LDQMF_20_SCALE;
995 275161 : hs->ds = 80;
996 275161 : hs->da = -40;
997 275161 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
998 275161 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
999 275161 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1000 275161 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1001 : }
1002 881846 : break;
1003 :
1004 0 : case 30:
1005 0 : hs->rot_vec_ana_re = rot_vec_ana_re_L30;
1006 0 : hs->rot_vec_ana_im = rot_vec_ana_im_L30;
1007 0 : hs->rot_vec_syn_re = rot_vec_syn_re_L30;
1008 0 : hs->rot_vec_syn_im = rot_vec_syn_im_L30;
1009 0 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1010 : {
1011 0 : hs->p_filter = CLDFB80_30;
1012 0 : hs->scale = CLDFB80_30_SCALE;
1013 0 : hs->ds = 30;
1014 0 : hs->da = 30;
1015 0 : hs->rot_vec_ana_delay_re = NULL;
1016 0 : hs->rot_vec_ana_delay_im = NULL;
1017 0 : hs->rot_vec_syn_delay_re = NULL;
1018 0 : hs->rot_vec_syn_delay_im = NULL;
1019 : }
1020 0 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
1021 : {
1022 0 : hs->p_filter = LDQMF_30;
1023 0 : hs->scale = LDQMF_30_SCALE;
1024 0 : hs->ds = 120;
1025 0 : hs->da = -60;
1026 0 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
1027 0 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
1028 0 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1029 0 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1030 : }
1031 0 : break;
1032 :
1033 43727 : case 32:
1034 43727 : hs->rot_vec_ana_re = rot_vec_ana_re_L32;
1035 43727 : hs->rot_vec_ana_im = rot_vec_ana_im_L32;
1036 43727 : hs->rot_vec_syn_re = rot_vec_syn_re_L32;
1037 43727 : hs->rot_vec_syn_im = rot_vec_syn_im_L32;
1038 43727 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1039 : {
1040 43727 : hs->p_filter = CLDFB80_32;
1041 43727 : hs->scale = CLDFB80_32_SCALE;
1042 43727 : hs->ds = 32;
1043 43727 : hs->da = 32;
1044 43727 : hs->rot_vec_ana_delay_re = NULL;
1045 43727 : hs->rot_vec_ana_delay_im = NULL;
1046 43727 : hs->rot_vec_syn_delay_re = NULL;
1047 43727 : hs->rot_vec_syn_delay_im = NULL;
1048 : }
1049 0 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
1050 : {
1051 0 : hs->p_filter = LDQMF_32;
1052 0 : hs->scale = LDQMF_32_SCALE;
1053 0 : hs->ds = 160;
1054 0 : hs->da = -80;
1055 0 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
1056 0 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
1057 0 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1058 0 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1059 : }
1060 43727 : break;
1061 :
1062 454783 : case 40:
1063 454783 : hs->rot_vec_ana_re = rot_vec_ana_re_L40;
1064 454783 : hs->rot_vec_ana_im = rot_vec_ana_im_L40;
1065 454783 : hs->rot_vec_syn_re = rot_vec_syn_re_L40;
1066 454783 : hs->rot_vec_syn_im = rot_vec_syn_im_L40;
1067 454783 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1068 : {
1069 175072 : hs->p_filter = CLDFB80_40;
1070 175072 : hs->scale = CLDFB80_40_SCALE;
1071 175072 : hs->ds = 40;
1072 175072 : hs->da = 40;
1073 175072 : hs->rot_vec_ana_delay_re = NULL;
1074 175072 : hs->rot_vec_ana_delay_im = NULL;
1075 175072 : hs->rot_vec_syn_delay_re = NULL;
1076 175072 : hs->rot_vec_syn_delay_im = NULL;
1077 : }
1078 279711 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
1079 : {
1080 279711 : hs->p_filter = LDQMF_40;
1081 279711 : hs->scale = LDQMF_40_SCALE;
1082 279711 : hs->ds = 160;
1083 279711 : hs->da = -80;
1084 279711 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
1085 279711 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
1086 279711 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1087 279711 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1088 : }
1089 454783 : break;
1090 :
1091 819714 : case 60:
1092 819714 : hs->rot_vec_ana_re = rot_vec_ana_re_L60;
1093 819714 : hs->rot_vec_ana_im = rot_vec_ana_im_L60;
1094 819714 : hs->rot_vec_syn_re = rot_vec_syn_re_L60;
1095 819714 : hs->rot_vec_syn_im = rot_vec_syn_im_L60;
1096 819714 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1097 : {
1098 428741 : hs->p_filter = CLDFB80_60;
1099 428741 : hs->scale = CLDFB80_60_SCALE;
1100 428741 : hs->ds = 60;
1101 428741 : hs->da = 60;
1102 428741 : hs->rot_vec_ana_delay_re = NULL;
1103 428741 : hs->rot_vec_ana_delay_im = NULL;
1104 428741 : hs->rot_vec_syn_delay_re = NULL;
1105 428741 : hs->rot_vec_syn_delay_im = NULL;
1106 : }
1107 390973 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
1108 : {
1109 390973 : hs->p_filter = LDQMF_60;
1110 390973 : hs->scale = LDQMF_60_SCALE;
1111 390973 : hs->ds = 240;
1112 390973 : hs->da = -120;
1113 390973 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
1114 390973 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
1115 390973 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1116 390973 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1117 : }
1118 819714 : break;
1119 : }
1120 :
1121 2561548 : return;
1122 : }
1123 :
1124 :
1125 : /*-------------------------------------------------------------------*
1126 : * cldfb_save_memory()
1127 : *
1128 : * Save the memory of filter; to be restored with cldfb_restore_memory()
1129 : *--------------------------------------------------------------------*/
1130 :
1131 465007 : ivas_error cldfb_save_memory(
1132 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
1133 : )
1134 : {
1135 465007 : uint16_t offset = hs->p_filter_length - hs->no_channels;
1136 :
1137 465007 : if ( hs->memory != NULL || hs->memory_length != 0 )
1138 : {
1139 : /* memory already stored; Free memory first */
1140 0 : return IVAS_ERR_OK;
1141 : }
1142 :
1143 465007 : if ( hs->type == CLDFB_ANALYSIS )
1144 : {
1145 232696 : hs->memory_length = offset;
1146 : }
1147 : else
1148 : {
1149 232311 : hs->memory_length = hs->p_filter_length;
1150 : }
1151 :
1152 465007 : if ( ( hs->memory = (float *) malloc( hs->memory_length * sizeof( float ) ) ) == NULL )
1153 : {
1154 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for CLDFB\n" );
1155 : }
1156 :
1157 : /* save the memory */
1158 465007 : mvr2r( hs->cldfb_state, hs->memory, hs->memory_length );
1159 :
1160 465007 : return IVAS_ERR_OK;
1161 : }
1162 :
1163 :
1164 : /*-------------------------------------------------------------------*
1165 : * cldfb_restore_memory()
1166 : *
1167 : * Restores the memory of filter; memory to be save by cldfb_save_memory()
1168 : *--------------------------------------------------------------------*/
1169 :
1170 465007 : void cldfb_restore_memory(
1171 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
1172 : )
1173 : {
1174 465007 : uint16_t offset = hs->p_filter_length - hs->no_channels;
1175 : uint16_t size;
1176 :
1177 465007 : if ( hs->memory == NULL || hs->memory_length == 0 )
1178 : {
1179 : /* memory not allocated */
1180 0 : return;
1181 : }
1182 :
1183 465007 : if ( hs->type == CLDFB_ANALYSIS )
1184 : {
1185 232696 : size = offset;
1186 : }
1187 : else
1188 : {
1189 232311 : size = hs->p_filter_length;
1190 : }
1191 :
1192 : /* read the memory */
1193 465007 : mvr2r( hs->memory, hs->cldfb_state, hs->memory_length );
1194 :
1195 : /* adjust sample rate if it was changed in the meanwhile */
1196 465007 : if ( hs->memory_length != size )
1197 : {
1198 0 : lerp( hs->cldfb_state, hs->cldfb_state, size, hs->memory_length );
1199 : }
1200 :
1201 465007 : hs->memory_length = 0;
1202 465007 : free( hs->memory );
1203 465007 : hs->memory = NULL;
1204 :
1205 465007 : return;
1206 : }
1207 :
1208 :
1209 : /*-------------------------------------------------------------------*
1210 : * cldfb_reset_memory()
1211 : *
1212 : * Resets the memory of filter.
1213 : *--------------------------------------------------------------------*/
1214 :
1215 45720310 : void cldfb_reset_memory(
1216 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
1217 : )
1218 : {
1219 45720310 : uint16_t offset = hs->p_filter_length - hs->no_channels;
1220 : int16_t memory_length;
1221 :
1222 45720310 : if ( hs->type == CLDFB_ANALYSIS )
1223 : {
1224 14290439 : memory_length = offset;
1225 : }
1226 : else
1227 : {
1228 31429871 : memory_length = hs->p_filter_length;
1229 : }
1230 :
1231 : /* save the memory */
1232 45720310 : set_f( hs->cldfb_state, 0, memory_length );
1233 :
1234 45720310 : return;
1235 : }
|
