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