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 710589016 : 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 710589016 : *yr = xr * cr - xi * ci;
82 710589016 : *yi = xr * ci + xi * cr;
83 :
84 710589016 : return;
85 : }
86 :
87 :
88 : /*-------------------------------------------------------------------*
89 : * cldfbAnalysis()
90 : *
91 : * Conduct multiple overlap complex low delay MDCT
92 : *--------------------------------------------------------------------*/
93 :
94 746520 : 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 746520 : 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 746520 : offset = h_cldfb->p_filter_length - h_cldfb->no_channels;
117 746520 : frameSize = h_cldfb->no_channels * h_cldfb->no_col;
118 :
119 746520 : assert( h_cldfb->prototype == CLDFB_PROTOTYPE_1_25MS );
120 : /* prepare input buffer */
121 746520 : timeBuffer = buffer;
122 746520 : mvr2r( h_cldfb->cldfb_state, timeBuffer, offset );
123 :
124 746520 : if ( samplesToProcess > -1 )
125 : {
126 346944 : mvr2r( timeIn, timeBuffer + offset, samplesToProcess );
127 346944 : set_f( timeBuffer + offset + samplesToProcess, 0.0f, ( frameSize - samplesToProcess ) );
128 : }
129 : else
130 : {
131 399576 : mvr2r( timeIn, timeBuffer + offset, frameSize );
132 : }
133 :
134 : /* only process needed cols */
135 746520 : if ( samplesToProcess > -1 )
136 : {
137 346944 : no_col = min( no_col, ( samplesToProcess + h_cldfb->no_channels - 1 ) / h_cldfb->no_channels );
138 : }
139 :
140 746520 : M1 = h_cldfb->no_channels;
141 746520 : M2 = M1 >> 1;
142 746520 : M4 = M1 >> 2;
143 746520 : L2 = M1 << 1;
144 :
145 746520 : if ( M2 & 1 )
146 : {
147 0 : M4 += 1;
148 : }
149 :
150 746520 : rot_vctr_re = h_cldfb->rot_vec_ana_re;
151 746520 : rot_vctr_im = h_cldfb->rot_vec_ana_im;
152 :
153 746520 : ptr_pf = h_cldfb->p_filter;
154 :
155 11953758 : for ( i = 0; i < no_col; i++ )
156 : {
157 100030865 : for ( k = 0; k < M4; k++ )
158 : {
159 : /* prototype filter */
160 88823627 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
161 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
162 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
163 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
164 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
165 :
166 88823627 : r2 = 0 - ptr_pf[( L2 - M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 0 * L2];
167 88823627 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 1 * L2];
168 88823627 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 2 * L2];
169 88823627 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 3 * L2];
170 88823627 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 4 * L2];
171 :
172 88823627 : i1 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
173 88823627 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
174 88823627 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
175 88823627 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
176 88823627 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 4 * L2];
177 :
178 88823627 : i2 = 0 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2];
179 88823627 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2];
180 88823627 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2];
181 88823627 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2];
182 88823627 : 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 88823627 : rr12 = r1 - r2;
186 88823627 : ri12 = -i1 - i2;
187 88823627 : 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 88823627 : ir12 = r1 + r2;
191 88823627 : ii12 = i1 - i2;
192 88823627 : cplxMult( &iBuffer[2 * k], &iBuffer[2 * k + 1], ir12, ii12, rot_vctr_re[k], rot_vctr_im[k] );
193 : }
194 :
195 100030865 : for ( k = M4; k < M2; k++ )
196 : {
197 : /* prototype filter */
198 88823627 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
199 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
200 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
201 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
202 88823627 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
203 :
204 88823627 : r2 = 0 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 0 * L2];
205 88823627 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 1 * L2];
206 88823627 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 2 * L2];
207 88823627 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 3 * L2];
208 88823627 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 4 * L2];
209 :
210 88823627 : i1 = 0 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 0 * L2];
211 88823627 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 1 * L2];
212 88823627 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 2 * L2];
213 88823627 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 3 * L2];
214 88823627 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 4 * L2];
215 :
216 88823627 : i2 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
217 88823627 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
218 88823627 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
219 88823627 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
220 88823627 : 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 88823627 : rr12 = r1 + r2;
224 88823627 : ri12 = i1 - i2;
225 88823627 : 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 88823627 : ir12 = r1 - r2;
229 88823627 : ii12 = i1 + i2;
230 88823627 : 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 11207238 : fft_cldfb( rBuffer, M2 );
235 :
236 : /* post modulation of DST IV */
237 188854492 : for ( k = 0; k < M2; k++ )
238 : {
239 177647254 : 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 11207238 : fft_cldfb( iBuffer, M2 );
244 :
245 : /* post modulation of DCT IV */
246 188854492 : for ( k = 0; k < M2; k++ )
247 : {
248 : /* do it inplace */
249 177647254 : 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 11207238 : timeBuffer += L2 * 5;
253 11207238 : timeBuffer += h_cldfb->no_channels - h_cldfb->p_filter_length;
254 : }
255 :
256 : /* update memory */
257 746520 : mvr2r( buffer + frameSize, h_cldfb->cldfb_state, offset );
258 :
259 746520 : return;
260 : }
261 :
262 : /*-------------------------------------------------------------------*
263 : * cldfbAnalysis_ts()
264 : *
265 : *
266 : *--------------------------------------------------------------------*/
267 :
268 39078783 : 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 39078783 : 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 39078783 : offset = h_cldfb->p_filter_length - h_cldfb->no_channels;
293 39078783 : frameSize = h_cldfb->no_channels * h_cldfb->no_col;
294 :
295 : /* prepare input buffer */
296 39078783 : timeBuffer = buffer;
297 39078783 : mvr2r( h_cldfb->cldfb_state, timeBuffer, offset );
298 :
299 39078783 : if ( samplesToProcess > -1 )
300 : {
301 39078783 : mvr2r( timeIn, timeBuffer + offset, samplesToProcess );
302 39078783 : 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 39078783 : if ( samplesToProcess > -1 )
311 : {
312 39078783 : no_col = min( no_col, ( samplesToProcess + h_cldfb->no_channels - 1 ) / h_cldfb->no_channels );
313 39078783 : assert( no_col == 1 );
314 : }
315 :
316 39078783 : M1 = h_cldfb->no_channels;
317 39078783 : M2 = M1 >> 1;
318 39078783 : M4 = M1 >> 2;
319 39078783 : L2 = M1 << 1;
320 :
321 39078783 : if ( M2 & 1 )
322 : {
323 0 : M4 += 1;
324 : }
325 :
326 39078783 : rot_vctr_re = h_cldfb->rot_vec_ana_re;
327 39078783 : rot_vctr_im = h_cldfb->rot_vec_ana_im;
328 39078783 : rot_vctr_delay_re = h_cldfb->rot_vec_ana_delay_re;
329 39078783 : rot_vctr_delay_im = h_cldfb->rot_vec_ana_delay_im;
330 :
331 39078783 : ptr_pf = h_cldfb->p_filter;
332 :
333 78157566 : for ( i = 0; i < no_col; i++ )
334 : {
335 596691416 : for ( k = 0; k < M4; k++ )
336 : {
337 : /* prototype filter */
338 557612633 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
339 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
340 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
341 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
342 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
343 :
344 557612633 : r2 = 0 - ptr_pf[( L2 - M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 0 * L2];
345 557612633 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 1 * L2];
346 557612633 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 2 * L2];
347 557612633 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 3 * L2];
348 557612633 : r2 = r2 - ptr_pf[( L2 - M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 + ( 2 * k ) + 4 * L2];
349 :
350 557612633 : i1 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
351 557612633 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
352 557612633 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
353 557612633 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
354 557612633 : i1 = i1 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 4 * L2];
355 :
356 557612633 : i2 = 0 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 0 * L2];
357 557612633 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 1 * L2];
358 557612633 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 2 * L2];
359 557612633 : i2 = i2 - ptr_pf[( L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 - 1 - ( 2 * k ) + 3 * L2];
360 557612633 : 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 557612633 : rr12 = r1 - r2;
364 557612633 : ri12 = -i1 - i2;
365 : /*cplxMult(&rBuffer[2*k],&rBuffer[2*k+1],rr12,ri12,rot_vctr_re[k],rot_vctr_im[k]);*/
366 557612633 : rBuffer[2 * k] = rr12 * rot_vctr_re[k] - ri12 * rot_vctr_im[k];
367 557612633 : rBuffer[2 * k + 1] = rr12 * rot_vctr_im[k] + ri12 * rot_vctr_re[k];
368 :
369 : /* folding + pre modulation of DCT IV */
370 557612633 : ir12 = r1 + r2;
371 557612633 : ii12 = i1 - i2;
372 : /*cplxMult(&iBuffer[2*k],&iBuffer[2*k+1],ir12,ii12,rot_vctr_re[k],rot_vctr_im[k]);*/
373 557612633 : iBuffer[2 * k] = ir12 * rot_vctr_re[k] - ii12 * rot_vctr_im[k];
374 557612633 : iBuffer[2 * k + 1] = ir12 * rot_vctr_im[k] + ii12 * rot_vctr_re[k];
375 : }
376 :
377 596691416 : for ( k = M4; k < M2; k++ )
378 : {
379 : /* prototype filter */
380 557612633 : r1 = 0 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 0 * L2];
381 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 1 * L2];
382 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 2 * L2];
383 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 3 * L2];
384 557612633 : r1 = r1 - ptr_pf[( L2 - M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - M2 - 1 - ( 2 * k ) + 4 * L2];
385 :
386 557612633 : r2 = 0 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 0 * L2];
387 557612633 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 1 * L2];
388 557612633 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 2 * L2];
389 557612633 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 3 * L2];
390 557612633 : r2 = r2 - ptr_pf[( L2 - 5 * M2 + ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 - 5 * M2 + ( 2 * k ) + 4 * L2];
391 :
392 557612633 : i1 = 0 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 0 * L2];
393 557612633 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 1 * L2];
394 557612633 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 2 * L2];
395 557612633 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 3 * L2];
396 557612633 : i1 = i1 - ptr_pf[( L2 + M2 - 1 - ( 2 * k ) + 4 * L2 )] * timeBuffer[L2 + M2 - 1 - ( 2 * k ) + 4 * L2];
397 :
398 557612633 : i2 = 0 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 0 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 0 * L2];
399 557612633 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 1 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 1 * L2];
400 557612633 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 2 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 2 * L2];
401 557612633 : i2 = i2 - ptr_pf[( L2 - 3 * M2 + ( 2 * k ) + 3 * L2 )] * timeBuffer[L2 - 3 * M2 + ( 2 * k ) + 3 * L2];
402 557612633 : 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 557612633 : rr12 = r1 + r2;
406 557612633 : ri12 = i1 - i2;
407 : /*cplxMult(&rBuffer[2*k],&rBuffer[2*k+1],rr12,ri12,rot_vctr_re[k],rot_vctr_im[k]);*/
408 557612633 : rBuffer[2 * k] = rr12 * rot_vctr_re[k] - ri12 * rot_vctr_im[k];
409 557612633 : rBuffer[2 * k + 1] = rr12 * rot_vctr_im[k] + ri12 * rot_vctr_re[k];
410 :
411 : /* folding + pre modulation of DCT IV */
412 557612633 : ir12 = r1 - r2;
413 557612633 : ii12 = i1 + i2;
414 : /*cplxMult(&iBuffer[2*k],&iBuffer[2*k+1],ir12,ii12,rot_vctr_re[k],rot_vctr_im[k]);*/
415 557612633 : iBuffer[2 * k] = ir12 * rot_vctr_re[k] - ii12 * rot_vctr_im[k];
416 557612633 : iBuffer[2 * k + 1] = ir12 * rot_vctr_im[k] + ii12 * rot_vctr_re[k];
417 : }
418 :
419 : /* FFT of DST IV */
420 39078783 : fft_cldfb( rBuffer, M2 );
421 :
422 : /* post modulation of DST IV */
423 1154304049 : 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 1115225266 : realBuffer[M1 - 1 - ( 2 * k )] = rBuffer[2 * k] * rot_vctr_re[k] - rBuffer[2 * k + 1] * rot_vctr_im[k];
427 1115225266 : 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 39078783 : fft_cldfb( iBuffer, M2 );
432 :
433 : /* post modulation of DCT IV */
434 1154304049 : 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 1115225266 : imagBuffer[2 * k] = iBuffer[2 * k] * rot_vctr_re[k] - iBuffer[2 * k + 1] * rot_vctr_im[k];
439 1115225266 : imagBuffer[M1 - 1 - ( 2 * k )] = iBuffer[2 * k] * rot_vctr_im[k] + iBuffer[2 * k + 1] * rot_vctr_re[k];
440 : }
441 :
442 39078783 : if ( h_cldfb->prototype == CLDFB_PROTOTYPE_5_00MS )
443 : {
444 : /* rotation due to delay*/
445 : /*if(h_cldfb->da != M1)*/
446 39078783 : if ( rot_vctr_delay_re != NULL )
447 : {
448 2269529315 : 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 2230450532 : cplx_aux = realBuffer[k] * rot_vctr_delay_re[k] - imagBuffer[k] * rot_vctr_delay_im[k];
459 2230450532 : imagBuffer[k] = realBuffer[k] * rot_vctr_delay_im[k] + imagBuffer[k] * rot_vctr_delay_re[k];
460 2230450532 : realBuffer[k] = cplx_aux;
461 : }
462 : }
463 : }
464 :
465 39078783 : timeBuffer += L2 * 5;
466 39078783 : timeBuffer += h_cldfb->no_channels - h_cldfb->p_filter_length;
467 : }
468 :
469 : /* update memory */
470 39078783 : if ( samplesToProcess > -1 )
471 : {
472 39078783 : 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 39078783 : return;
480 : }
481 :
482 : /*-------------------------------------------------------------------*
483 : * cldfbSynthesis()
484 : *
485 : * Conduct inverse multple overlap cmplex low delay MDCT
486 : *--------------------------------------------------------------------*/
487 :
488 17608468 : 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 17608468 : int16_t no_col = h_cldfb->no_col;
522 :
523 17608468 : M1 = h_cldfb->no_channels;
524 17608468 : L2 = M1 << 1;
525 17608468 : M2 = M1 >> 1;
526 17608468 : M41 = M2 >> 1;
527 17608468 : M42 = M2 - M41;
528 17608468 : Mz = M1 - h_cldfb->bandsToZero;
529 :
530 : /* only process needed cols */
531 17608468 : if ( samplesToProcess > -1 )
532 : {
533 17310785 : no_col = min( no_col, ( samplesToProcess + h_cldfb->no_channels - 1 ) / h_cldfb->no_channels );
534 : }
535 :
536 17608468 : rot_vctr_re = h_cldfb->rot_vec_syn_re;
537 17608468 : rot_vctr_im = h_cldfb->rot_vec_syn_im;
538 :
539 17608468 : rot_vctr_delay_re = h_cldfb->rot_vec_syn_delay_re;
540 17608468 : rot_vctr_delay_im = h_cldfb->rot_vec_syn_delay_im;
541 :
542 17608468 : synthesisBuffer = buffer;
543 17608468 : mvr2r( h_cldfb->cldfb_state, synthesisBuffer + ( M1 * no_col ), h_cldfb->p_filter_length );
544 :
545 17608468 : p_filter = h_cldfb->p_filter;
546 17608468 : ptr_time_out = timeOut;
547 :
548 : /*synthesisBuffer += M1 * h_cldfb->no_col;*/
549 17608468 : synthesisBuffer += M1 * no_col;
550 :
551 51225942 : for ( k = 0; k < no_col; k++ )
552 : {
553 33617474 : if ( h_cldfb->prototype == CLDFB_PROTOTYPE_5_00MS )
554 : {
555 : /* rotation due to delay*/
556 : /*if(h_cldfb->ds != M1)*/
557 28375861 : if ( rot_vctr_delay_re != NULL )
558 : {
559 1618935241 : 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 1590559380 : cplx_aux = realBuffer[k][i] * rot_vctr_delay_re[i] - imagBuffer[k][i] * rot_vctr_delay_im[i];
568 1590559380 : imagBuffer[k][i] = realBuffer[k][i] * rot_vctr_delay_im[i] + imagBuffer[k][i] * rot_vctr_delay_re[i];
569 1590559380 : realBuffer[k][i] = cplx_aux;
570 : /*realBuffer[k][i] = rBuffer[i];
571 : imagBuffer[k][i] = iBuffer[i];*/
572 : }
573 : }
574 : }
575 160695898 : for ( i = Mz; i < M1; i++ )
576 : {
577 127078424 : realBuffer[k][i] = 0.0f;
578 127078424 : imagBuffer[k][i] = 0.0f;
579 : }
580 :
581 946964754 : 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 913347280 : rBuffer[2 * i] = realBuffer[k][2 * i] * rot_vctr_re[i] - realBuffer[k][M1 - 1 - 2 * i] * rot_vctr_im[i];
586 913347280 : 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 913347280 : iBuffer[2 * i] = ( -( imagBuffer[k][2 * i] ) ) * rot_vctr_re[i] - imagBuffer[k][M1 - 1 - 2 * i] * rot_vctr_im[i];
591 913347280 : 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 33617474 : fft_cldfb( rBuffer, M2 );
596 :
597 : /* FFT of DCT IV */
598 33617474 : fft_cldfb( iBuffer, M2 );
599 :
600 : /* folding */
601 490291114 : for ( i = 0; i < M41; i++ )
602 : {
603 : /* post modulation of DST IV */
604 456673640 : rr12 = rBuffer[M1 - 2 - 2 * i] * rot_vctr_re[M2 - 1 - i] - rBuffer[M1 - 1 - 2 * i] * rot_vctr_im[M2 - 1 - i];
605 456673640 : 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 456673640 : ir12 = iBuffer[M1 - 2 - 2 * i] * rot_vctr_re[M2 - 1 - i] - iBuffer[M1 - 1 - 2 * i] * rot_vctr_im[M2 - 1 - i];
609 456673640 : 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 456673640 : new_samples[M1 + M2 + 1 + 2 * i] = -rr12 - ii12;
612 456673640 : new_samples[M2 - 2 - 2 * i] = -ri12 - ir12;
613 :
614 456673640 : new_samples[M1 + M2 - 2 - 2 * i] = rr12 - ii12;
615 456673640 : new_samples[M2 + 1 + 2 * i] = ir12 - ri12;
616 : }
617 :
618 490291114 : for ( i = 0; i < M42; i++ )
619 : {
620 : /* post modulation of DST IV */
621 456673640 : rr12 = rBuffer[2 * i] * rot_vctr_re[i] - rBuffer[2 * i + 1] * rot_vctr_im[i];
622 456673640 : ri12 = rBuffer[2 * i] * rot_vctr_im[i] + rBuffer[2 * i + 1] * rot_vctr_re[i];
623 :
624 : /* post modulation of DCT IV */
625 456673640 : ir12 = iBuffer[2 * i] * rot_vctr_re[i] - iBuffer[2 * i + 1] * rot_vctr_im[i];
626 456673640 : ii12 = iBuffer[2 * i] * rot_vctr_im[i] + iBuffer[2 * i + 1] * rot_vctr_re[i];
627 :
628 456673640 : new_samples[M1 + M2 + 2 * i] = ri12 + ir12;
629 456673640 : new_samples[M2 - 1 - 2 * i] = rr12 + ii12;
630 :
631 456673640 : new_samples[M1 + M2 - 1 - 2 * i] = ir12 - ri12;
632 456673640 : new_samples[M2 + 2 * i] = rr12 - ii12;
633 : }
634 :
635 : /* synthesis prototype filter */
636 3687006594 : for ( i = 0; i < L2; i++ )
637 : {
638 3653389120 : accu0 = synthesisBuffer[0 * L2 + i] + p_filter[( 0 * L2 + i )] * new_samples[L2 - 1 - i];
639 3653389120 : accu1 = synthesisBuffer[1 * L2 + i] + p_filter[( 1 * L2 + i )] * new_samples[L2 - 1 - i];
640 3653389120 : accu2 = synthesisBuffer[2 * L2 + i] + p_filter[( 2 * L2 + i )] * new_samples[L2 - 1 - i];
641 3653389120 : accu3 = synthesisBuffer[3 * L2 + i] + p_filter[( 3 * L2 + i )] * new_samples[L2 - 1 - i];
642 3653389120 : accu4 = synthesisBuffer[4 * L2 + i] + p_filter[( 4 * L2 + i )] * new_samples[L2 - 1 - i];
643 :
644 3653389120 : synthesisBuffer[0 * L2 + i] = accu0;
645 3653389120 : synthesisBuffer[1 * L2 + i] = accu1;
646 3653389120 : synthesisBuffer[2 * L2 + i] = accu2;
647 3653389120 : synthesisBuffer[3 * L2 + i] = accu3;
648 3653389120 : synthesisBuffer[4 * L2 + i] = accu4;
649 : }
650 :
651 1860312034 : for ( i = 0; i < M1; i++ )
652 : {
653 1826694560 : ptr_time_out[M1 - 1 - i] = synthesisBuffer[4 * L2 + M1 + i];
654 : }
655 :
656 33617474 : ptr_time_out += M1;
657 :
658 33617474 : synthesisBuffer -= M1;
659 :
660 33617474 : set_f( synthesisBuffer, 0, M1 );
661 : }
662 :
663 : /* update memory */
664 17608468 : mvr2r( buffer, h_cldfb->cldfb_state, h_cldfb->p_filter_length );
665 :
666 17608468 : return;
667 : }
668 :
669 : /*-------------------------------------------------------------------*
670 : * configureClfdb()
671 : *
672 : * configures a CLDFB handle
673 : *--------------------------------------------------------------------*/
674 :
675 89350 : 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 89350 : h_cldfb->no_col = CLDFB_NO_COL_MAX;
682 89350 : h_cldfb->bandsToZero = 0;
683 89350 : h_cldfb->nab = 0;
684 :
685 89350 : h_cldfb->no_channels = (int16_t) ( sampling_rate * INV_CLDFB_BANDWIDTH + 0.5f );
686 89350 : h_cldfb->p_filter_length = 10 * h_cldfb->no_channels;
687 :
688 89350 : cldfb_init_proto_and_twiddles( h_cldfb );
689 :
690 89350 : return;
691 : }
692 :
693 : /*-------------------------------------------------------------------*
694 : * openClfdb()
695 : *
696 : * open and configures a CLDFB handle
697 : *--------------------------------------------------------------------*/
698 :
699 63541 : 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 63541 : 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 63541 : hs->type = type;
715 63541 : hs->prototype = prototype;
716 :
717 63541 : configureCldfb( hs, sampling_rate );
718 63541 : hs->memory = NULL;
719 63541 : hs->memory_length = 0;
720 :
721 63541 : if ( type == CLDFB_ANALYSIS )
722 : {
723 29714 : buf_len = hs->p_filter_length - hs->no_channels;
724 : }
725 : else
726 : {
727 33827 : buf_len = hs->p_filter_length;
728 : }
729 :
730 63541 : 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 63541 : set_f( hs->cldfb_state, 0.0f, buf_len );
736 :
737 63541 : *h_cldfb = hs;
738 :
739 63541 : return IVAS_ERR_OK;
740 : }
741 :
742 :
743 : /*-------------------------------------------------------------------*
744 : * resampleCldfb()
745 : *
746 : * Change sample rate of filter bank
747 : *--------------------------------------------------------------------*/
748 :
749 18951 : 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 18951 : int16_t timeOffsetold = hs->p_filter_length - hs->no_channels;
757 :
758 : /* new settings */
759 18951 : configureCldfb( hs, newSamplerate );
760 18951 : 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 18951 : lerp( hs->cldfb_state, hs->cldfb_state, timeOffset, timeOffsetold );
764 :
765 18951 : return;
766 : }
767 :
768 : /*-------------------------------------------------------------------*
769 : * analysisCLDFBEncoder()
770 : *
771 : * Encoder CLDFB analysis + energy stage
772 : *--------------------------------------------------------------------*/
773 :
774 245896 : 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 4180232 : for ( i = 0; i < CLDFB_NO_COL_MAX; i++ )
787 : {
788 3934336 : ppBuf_Real[i] = &realBuffer[i][0];
789 3934336 : ppBuf_Imag[i] = &imagBuffer[i][0];
790 : }
791 :
792 245896 : cldfbAnalysis( timeIn, ppBuf_Real, ppBuf_Imag, samplesToProcess, st->cldfbAnaEnc );
793 :
794 245896 : st->currEnergyHF = GetEnergyCldfb( ppBuf_Ener, &st->currEnergyLookAhead, ppBuf_Real, ppBuf_Imag, st->cldfbAnaEnc->no_channels, st->cldfbAnaEnc->no_col, st->hTECEnc );
795 :
796 245896 : return;
797 : }
798 :
799 : /*-------------------------------------------------------------------*
800 : * GetEnergyCldfb()
801 : *
802 : * Conduct energy from complex data
803 : *--------------------------------------------------------------------*/
804 :
805 245896 : 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 245896 : int16_t numLookahead = 1;
818 :
819 4180232 : for ( k = 0; k < numberCols; k++ )
820 : {
821 229030016 : for ( j = 0; j < numberBands; j++ )
822 : {
823 225095680 : energyValues[k][j] = realValues[k][j] * realValues[k][j] +
824 225095680 : imagValues[k][j] * imagValues[k][j];
825 : }
826 : }
827 :
828 245896 : if ( numberBands >= freqTable[1] && hTecEnc != NULL )
829 : {
830 : float *tempEnergyValuesArry[CLDFB_NO_COL_MAX];
831 :
832 3100 : assert( numberCols == CLDFB_NO_COL_MAX );
833 52700 : for ( j = 0; j < numberCols; j++ )
834 : {
835 49600 : tempEnergyValuesArry[j] = &energyValues[j][0];
836 : }
837 :
838 3100 : calcHiEnvLoBuff( numberCols, freqTable, 1, tempEnergyValuesArry, hTecEnc->loBuffer, hTecEnc->hiTempEnv );
839 : }
840 :
841 14314376 : for ( j = 0; j < numberBands; j++ )
842 : {
843 14068480 : energyValuesSum[j] = 0;
844 239164160 : for ( k = 0; k < CLDFB_NO_COL_MAX; k++ )
845 : {
846 225095680 : energyValuesSum[j] += energyValues[k][j];
847 : }
848 : }
849 :
850 245896 : if ( numberBands > 20 )
851 : {
852 239247 : float energyHF = *energyLookahead; /* energy above 8 kHz */
853 239247 : numberCols -= numLookahead;
854 239247 : *energyLookahead = 6.1e-5f; /* process look-ahead region */
855 :
856 5024187 : for ( j = 20; j < min( 40, numberBands ); j++ )
857 : {
858 4784940 : energyHF += energyValuesSum[j];
859 :
860 9569880 : for ( k = numberCols; k < CLDFB_NO_COL_MAX; k++ )
861 : {
862 4784940 : energyHF -= energyValues[k][j];
863 4784940 : *energyLookahead += energyValues[k][j];
864 : }
865 : }
866 :
867 239247 : return energyHF * OUTMAX_SQ_INV;
868 : }
869 :
870 6649 : return 65535.0f;
871 : }
872 :
873 :
874 : /*-------------------------------------------------------------------*
875 : * GetEnergyCldfb()
876 : *
877 : * Remove handle
878 : *--------------------------------------------------------------------*/
879 :
880 106778 : void deleteCldfb(
881 : HANDLE_CLDFB_FILTER_BANK *h_cldfb /* i/o: filter bank handle */
882 : )
883 : {
884 106778 : HANDLE_CLDFB_FILTER_BANK hs = *h_cldfb;
885 :
886 106778 : if ( h_cldfb == NULL || *h_cldfb == NULL )
887 : {
888 43237 : return;
889 : }
890 :
891 63541 : if ( hs->cldfb_state )
892 : {
893 63541 : free( hs->cldfb_state );
894 : }
895 :
896 63541 : free( hs );
897 63541 : *h_cldfb = NULL;
898 :
899 63541 : return;
900 : }
901 :
902 :
903 : /*-------------------------------------------------------------------*
904 : * cldfb_init_proto_and_twiddles()
905 : *
906 : * Initializes rom pointer
907 : *--------------------------------------------------------------------*/
908 :
909 89350 : 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 89350 : switch ( hs->no_channels )
915 : {
916 0 : case 10:
917 0 : hs->rot_vec_ana_re = rot_vec_ana_re_L10;
918 0 : hs->rot_vec_ana_im = rot_vec_ana_im_L10;
919 0 : hs->rot_vec_syn_re = rot_vec_syn_re_L10;
920 0 : hs->rot_vec_syn_im = rot_vec_syn_im_L10;
921 :
922 0 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
923 : {
924 0 : hs->p_filter = CLDFB80_10;
925 0 : hs->scale = CLDFB80_10_SCALE;
926 0 : hs->ds = 10;
927 0 : hs->da = 10;
928 0 : hs->rot_vec_ana_delay_re = NULL;
929 0 : hs->rot_vec_ana_delay_im = NULL;
930 0 : hs->rot_vec_syn_delay_re = NULL;
931 0 : 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 0 : break;
945 :
946 11770 : case 16:
947 11770 : hs->rot_vec_ana_re = rot_vec_ana_re_L16;
948 11770 : hs->rot_vec_ana_im = rot_vec_ana_im_L16;
949 11770 : hs->rot_vec_syn_re = rot_vec_syn_re_L16;
950 11770 : hs->rot_vec_syn_im = rot_vec_syn_im_L16;
951 11770 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
952 : {
953 11532 : hs->p_filter = CLDFB80_16;
954 11532 : hs->scale = CLDFB80_16_SCALE;
955 11532 : hs->ds = 20;
956 11532 : hs->da = 20;
957 11532 : hs->rot_vec_ana_delay_re = NULL;
958 11532 : hs->rot_vec_ana_delay_im = NULL;
959 11532 : hs->rot_vec_syn_delay_re = NULL;
960 11532 : hs->rot_vec_syn_delay_im = NULL;
961 : }
962 238 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
963 : {
964 238 : hs->p_filter = LDQMF_16;
965 238 : hs->scale = LDQMF_16_SCALE;
966 238 : hs->ds = 80;
967 238 : hs->da = -40;
968 238 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
969 238 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
970 238 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
971 238 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
972 : }
973 11770 : break;
974 :
975 19293 : case 20:
976 19293 : hs->rot_vec_ana_re = rot_vec_ana_re_L20;
977 19293 : hs->rot_vec_ana_im = rot_vec_ana_im_L20;
978 19293 : hs->rot_vec_syn_re = rot_vec_syn_re_L20;
979 19293 : hs->rot_vec_syn_im = rot_vec_syn_im_L20;
980 19293 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
981 : {
982 17435 : hs->p_filter = CLDFB80_20;
983 17435 : hs->scale = CLDFB80_20_SCALE;
984 17435 : hs->ds = 20;
985 17435 : hs->da = 20;
986 17435 : hs->rot_vec_ana_delay_re = NULL;
987 17435 : hs->rot_vec_ana_delay_im = NULL;
988 17435 : hs->rot_vec_syn_delay_re = NULL;
989 17435 : hs->rot_vec_syn_delay_im = NULL;
990 : }
991 1858 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
992 : {
993 1858 : hs->p_filter = LDQMF_20;
994 1858 : hs->scale = LDQMF_20_SCALE;
995 1858 : hs->ds = 80;
996 1858 : hs->da = -40;
997 1858 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
998 1858 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
999 1858 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1000 1858 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1001 : }
1002 19293 : 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 2025 : case 32:
1034 2025 : hs->rot_vec_ana_re = rot_vec_ana_re_L32;
1035 2025 : hs->rot_vec_ana_im = rot_vec_ana_im_L32;
1036 2025 : hs->rot_vec_syn_re = rot_vec_syn_re_L32;
1037 2025 : hs->rot_vec_syn_im = rot_vec_syn_im_L32;
1038 2025 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1039 : {
1040 2025 : hs->p_filter = CLDFB80_32;
1041 2025 : hs->scale = CLDFB80_32_SCALE;
1042 2025 : hs->ds = 32;
1043 2025 : hs->da = 32;
1044 2025 : hs->rot_vec_ana_delay_re = NULL;
1045 2025 : hs->rot_vec_ana_delay_im = NULL;
1046 2025 : hs->rot_vec_syn_delay_re = NULL;
1047 2025 : 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 2025 : break;
1061 :
1062 6020 : case 40:
1063 6020 : hs->rot_vec_ana_re = rot_vec_ana_re_L40;
1064 6020 : hs->rot_vec_ana_im = rot_vec_ana_im_L40;
1065 6020 : hs->rot_vec_syn_re = rot_vec_syn_re_L40;
1066 6020 : hs->rot_vec_syn_im = rot_vec_syn_im_L40;
1067 6020 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1068 : {
1069 3648 : hs->p_filter = CLDFB80_40;
1070 3648 : hs->scale = CLDFB80_40_SCALE;
1071 3648 : hs->ds = 40;
1072 3648 : hs->da = 40;
1073 3648 : hs->rot_vec_ana_delay_re = NULL;
1074 3648 : hs->rot_vec_ana_delay_im = NULL;
1075 3648 : hs->rot_vec_syn_delay_re = NULL;
1076 3648 : hs->rot_vec_syn_delay_im = NULL;
1077 : }
1078 2372 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
1079 : {
1080 2372 : hs->p_filter = LDQMF_40;
1081 2372 : hs->scale = LDQMF_40_SCALE;
1082 2372 : hs->ds = 160;
1083 2372 : hs->da = -80;
1084 2372 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
1085 2372 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
1086 2372 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1087 2372 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1088 : }
1089 6020 : break;
1090 :
1091 50242 : case 60:
1092 50242 : hs->rot_vec_ana_re = rot_vec_ana_re_L60;
1093 50242 : hs->rot_vec_ana_im = rot_vec_ana_im_L60;
1094 50242 : hs->rot_vec_syn_re = rot_vec_syn_re_L60;
1095 50242 : hs->rot_vec_syn_im = rot_vec_syn_im_L60;
1096 50242 : if ( hs->prototype == CLDFB_PROTOTYPE_1_25MS )
1097 : {
1098 18953 : hs->p_filter = CLDFB80_60;
1099 18953 : hs->scale = CLDFB80_60_SCALE;
1100 18953 : hs->ds = 60;
1101 18953 : hs->da = 60;
1102 18953 : hs->rot_vec_ana_delay_re = NULL;
1103 18953 : hs->rot_vec_ana_delay_im = NULL;
1104 18953 : hs->rot_vec_syn_delay_re = NULL;
1105 18953 : hs->rot_vec_syn_delay_im = NULL;
1106 : }
1107 31289 : else if ( hs->prototype == CLDFB_PROTOTYPE_5_00MS )
1108 : {
1109 31289 : hs->p_filter = LDQMF_60;
1110 31289 : hs->scale = LDQMF_60_SCALE;
1111 31289 : hs->ds = 240;
1112 31289 : hs->da = -120;
1113 31289 : hs->rot_vec_ana_delay_re = rot_vec_delay_re_LDQMF;
1114 31289 : hs->rot_vec_ana_delay_im = rot_vec_delay_im_LDQMF;
1115 31289 : hs->rot_vec_syn_delay_re = rot_vec_delay_re_LDQMF;
1116 31289 : hs->rot_vec_syn_delay_im = rot_vec_delay_im_LDQMF;
1117 : }
1118 50242 : break;
1119 : }
1120 :
1121 89350 : 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 11711 : ivas_error cldfb_save_memory(
1132 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
1133 : )
1134 : {
1135 11711 : uint16_t offset = hs->p_filter_length - hs->no_channels;
1136 :
1137 11711 : 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 11711 : if ( hs->type == CLDFB_ANALYSIS )
1144 : {
1145 5873 : hs->memory_length = offset;
1146 : }
1147 : else
1148 : {
1149 5838 : hs->memory_length = hs->p_filter_length;
1150 : }
1151 :
1152 11711 : 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 11711 : mvr2r( hs->cldfb_state, hs->memory, hs->memory_length );
1159 :
1160 11711 : 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 11711 : void cldfb_restore_memory(
1171 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
1172 : )
1173 : {
1174 11711 : uint16_t offset = hs->p_filter_length - hs->no_channels;
1175 : uint16_t size;
1176 :
1177 11711 : if ( hs->memory == NULL || hs->memory_length == 0 )
1178 : {
1179 : /* memory not allocated */
1180 0 : return;
1181 : }
1182 :
1183 11711 : if ( hs->type == CLDFB_ANALYSIS )
1184 : {
1185 5873 : size = offset;
1186 : }
1187 : else
1188 : {
1189 5838 : size = hs->p_filter_length;
1190 : }
1191 :
1192 : /* read the memory */
1193 11711 : mvr2r( hs->memory, hs->cldfb_state, hs->memory_length );
1194 :
1195 : /* adjust sample rate if it was changed in the meanwhile */
1196 11711 : if ( hs->memory_length != size )
1197 : {
1198 0 : lerp( hs->cldfb_state, hs->cldfb_state, size, hs->memory_length );
1199 : }
1200 :
1201 11711 : hs->memory_length = 0;
1202 11711 : free( hs->memory );
1203 11711 : hs->memory = NULL;
1204 :
1205 11711 : return;
1206 : }
1207 :
1208 :
1209 : /*-------------------------------------------------------------------*
1210 : * cldfb_reset_memory()
1211 : *
1212 : * Resets the memory of filter.
1213 : *--------------------------------------------------------------------*/
1214 :
1215 2445403 : void cldfb_reset_memory(
1216 : HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
1217 : )
1218 : {
1219 2445403 : uint16_t offset = hs->p_filter_length - hs->no_channels;
1220 : int16_t memory_length;
1221 :
1222 2445403 : if ( hs->type == CLDFB_ANALYSIS )
1223 : {
1224 642253 : memory_length = offset;
1225 : }
1226 : else
1227 : {
1228 1803150 : memory_length = hs->p_filter_length;
1229 : }
1230 :
1231 : /* save the memory */
1232 2445403 : set_f( hs->cldfb_state, 0, memory_length );
1233 :
1234 2445403 : return;
1235 : }
|
