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 : #include <stdint.h>
34 : #include <math.h>
35 : #include "options.h"
36 : #include "cnst.h"
37 : #include "ivas_cnst.h"
38 : #include "rom_com.h"
39 : #include "prot.h"
40 : #include "ivas_prot.h"
41 : #include "ivas_rom_com.h"
42 : #include "ivas_rom_enc.h"
43 : #ifdef DEBUGGING
44 : #include "debug.h"
45 : #endif
46 : #include "wmc_auto.h"
47 :
48 :
49 : /*-----------------------------------------------------------------------*
50 : * Local constants
51 : *-----------------------------------------------------------------------*/
52 :
53 : #define STEREO_DMX_EVS_FIND_POC_PEAK_TAU 4
54 : #define STEREO_DMX_EVS_FIND_POC_PEAK_TAU2 8
55 :
56 : #define STEREO_DMX_EVS_POC_GAMMA 0.75f
57 : #define STEREO_DMX_EVS_POC_SMOOTH 1.25f
58 : #define STEREO_DMX_EVS_POC_FORGETTING 0.78f
59 : #define STEREO_DMX_EVS_TARGET_POC_FORGETTING 0.79f
60 : #define STEREO_DMX_EVS_POC_W_FORGETTING 0.875f
61 : #define STEREO_DMX_EVS_SHIFT_LIMIT STEREO_DFT_ZP_NS_ENC
62 :
63 : #define STEREO_DMX_EVS_DMX_EGY_FORGETTING 0.25f
64 : #define STEREO_DMX_EVS_CORR_FORGETTING 0.78f
65 :
66 : #define Q_BAND 0.25f
67 :
68 :
69 : #define STEREO_DMX_EVS_ISD_FORGETTING 0.95f
70 : #define STEREO_DMX_EVS_ISD_THRES_H 1.69f
71 : #define STEREO_DMX_EVS_ISD_THRES_L 0.9f
72 : #define STEREO_DMX_EVS_ISD_DIST_THRES_IPD 0.5f
73 :
74 : #define STEREO_DMX_EVS_ISD_DIST_HYST_L 0.36f
75 : #define STEREO_DMX_EVS_ISD_DIST_HYST_H 0.43f
76 :
77 : #define STEREO_DMX_EVS_ICCR_FORGETTING 0.7f
78 : #define STEREO_DMX_EVS_ICCR_HYST_L 0.75f
79 : #define STEREO_DMX_EVS_ICCR_HYST_H 0.85f
80 :
81 : #define STEREO_DMX_EVS_ICCRES_FORGETTING 0.92f
82 : #define STEREO_DMX_EVS_LVLU_FORGETTING 0.5f
83 : #define STEREO_DMX_EVS_LVLD_FORGETTING 0.92f
84 : #define STEREO_DMX_EVS_ICLD_THRESH 3.f
85 : #define STEREO_DMX_EVS_ICCRES_THRESH 0.4f
86 : #define STEREO_DMX_EVS_DICLD_THRESH 1.49623566f
87 :
88 : #define STEREO_DMX_EVS_SWTCH_HYS_THRES 1
89 : #define STEREO_DMX_EVS_LR_EGY 15.0f
90 : #define STEREO_DMX_EVS_ILDS_EGY 10000.0f
91 : #define STEREO_DMX_EVS_ILD_PRC 0.1f
92 :
93 : #define STEREO_DMX_EVS_SWTCH_PRC_THRES_16 55
94 : #define STEREO_DMX_EVS_SWTCH_PRC_THRES_32 19
95 : #define STEREO_DMX_EVS_SWTCH_PRC_THRES_48 29
96 :
97 : #define STEREO_DMX_EVS_SWTCH_PRC_HYS_THRES 1
98 : #define STEREO_DMX_EVS_IFF_AMIN 0.857696f
99 : #define STEREO_DMX_EVS_IFF_AMAX 0.944061f
100 : #define STEREO_DMX_EVS_IFF_FREQ 3000.0f
101 : #define STEREO_DMX_EVS_PHA_WND_C 1.8f
102 :
103 : #define STEREO_DMX_EVS_NB_SBFRM 5
104 : #define STEREO_DMX_EVS_TRNS_DTC_INST 75.0f
105 : #define STEREO_DMX_EVS_CRST_FCTR_16 80.0f
106 : #define STEREO_DMX_EVS_CRST_FCTR_32 40.0f
107 : #define STEREO_DMX_EVS_CRST_FCTR_48 35.0f
108 :
109 : #define STEREO_DMX_EVS_TRNS_EGY_FORGETTING 0.75f
110 :
111 : #define STEREO_DMX_EVS_FAD_R 3
112 : #define STEREO_DMX_EVS_SGC_EGY_FORGETTING 0.9f
113 : #define STEREO_DMX_EVS_SGC_GR_S 1.00461543f
114 : #define STEREO_DMX_EVS_SGC_GL 0.9885f
115 : #define STEREO_DMX_EVS_SGC_GH 1.0116f
116 : #define STEREO_DMX_EVS_SGC_LEGY_THRES_16 2.5E8
117 : #define STEREO_DMX_EVS_SGC_LEGY_THRES_32 3.E8
118 : #define STEREO_DMX_EVS_SGC_LEGY_THRES_48 5.E8
119 : #define STEREO_DMX_EVS_SGC_GMAX 1.4142f
120 : #define STEREO_DMX_EVS_SGC_GMIN 0.7071f
121 :
122 : #define STEREO_DMX_EVS_IPD_ILD_THRES 3.16f // 5dB
123 : #define STEREO_DMX_EVS_IPD_SF_THRES 0.05f
124 :
125 : /*-----------------------------------------------------------------------*
126 : * Local function prototypes
127 : *-----------------------------------------------------------------------*/
128 :
129 : static void estimate_itd_wnd_fft( const float *input, float *specr, float *speci, const float *rfft_coef, const float *wnd, const int16_t input_frame );
130 : static void calc_poc( STEREO_DMX_EVS_POC_HANDLE hPOC, STEREO_DMX_EVS_PHA_HANDLE hPHA, const float wnd[], const float rfft_coef[], const float specLr[], const float specLi[], const float specRr[], const float specRi[], const int16_t input_frame );
131 : static ivas_error estimate_itd( float *corr, STEREO_DMX_EVS_POC_HANDLE hPOC, STEREO_DMX_EVS_PHA_HANDLE hPHA, const float srcL[], const float srcR[], float itd[], const int16_t input_frame );
132 : static void weighted_ave( const float src1[], const float src2[], float dst[], const float gain, const float old_gain, const int16_t input_frame, const float wnd[] );
133 : static void adapt_gain( const float src[], float dst[], const float gain, const float old_gain, const int16_t input_frame, const float wnd[] );
134 : static float find_poc_peak( STEREO_DMX_EVS_POC_HANDLE hPOC, float itd[], const int16_t input_frame, const float ratio );
135 : static float spectral_flatness( const float sig[], const int16_t sig_length );
136 : static void create_M_signal( const float srcL[], const float srcR[], float dmx[], const float w_curr, const int16_t input_frame, const float wnd[], float *w_prev, float *dmx_energy, float *src_energy, STEREO_DMX_EVS_PHA_HANDLE hPHA );
137 : static void calc_energy( const float src1[], const float src2[], float energy[], float *lvl, const int16_t input_frame, const float ratio );
138 :
139 : /*-------------------------------------------------------------------*
140 : * estimate_itd_wnd_fft()
141 : *
142 : * Transforms input signal from time domain into frequency domain.
143 : * The input signal is windowed before being transformed.
144 : *-------------------------------------------------------------------*/
145 :
146 17700 : void estimate_itd_wnd_fft(
147 : const float *input, /* i : input signal */
148 : float *specr, /* o : real-part spectra */
149 : float *speci, /* o : imaginary-part spectra */
150 : const float *rfft_coef, /* i : rfft coef */
151 : const float *wnd, /* i : window coef */
152 : const int16_t input_frame /* i : input frame length per channel */
153 : )
154 : {
155 : int16_t n0, i;
156 : float rfft_buf[L_FRAME48k];
157 : int16_t step, bias;
158 :
159 17700 : n0 = input_frame >> 1;
160 17700 : if ( input_frame == L_FRAME16k )
161 : {
162 6000 : step = 3;
163 6000 : bias = 1;
164 : }
165 : else
166 : {
167 11700 : step = 1;
168 11700 : bias = 0;
169 : }
170 :
171 11345700 : for ( i = 0; i < input_frame; i++ )
172 : {
173 : /* window */
174 11328000 : rfft_buf[i] = input[i] * wnd[i * step + bias];
175 : }
176 :
177 17700 : rfft( rfft_buf, rfft_coef, input_frame, -1 );
178 :
179 5664000 : for ( i = 1; i < n0; i++ )
180 : {
181 5646300 : specr[i] = rfft_buf[i * 2];
182 5646300 : speci[i] = rfft_buf[i * 2 + 1];
183 : }
184 :
185 17700 : specr[0] = rfft_buf[0];
186 17700 : specr[n0] = rfft_buf[1];
187 17700 : speci[0] = 0.f;
188 17700 : speci[n0] = 0.f;
189 :
190 17700 : return;
191 : }
192 :
193 :
194 : /*-------------------------------------------------------------------*
195 : * calc_poc()
196 : *
197 : * calculate phase only correlation
198 : *-------------------------------------------------------------------*/
199 :
200 8850 : static void calc_poc(
201 : STEREO_DMX_EVS_POC_HANDLE hPOC, /* i/o: phase only correlation structure */
202 : STEREO_DMX_EVS_PHA_HANDLE hPHA, /* i/o: correlation filter structure */
203 : const float wnd[], /* i : window coef */
204 : const float rfft_coef[], /* i : RFFT coef */
205 : const float specLr[], /* i : Lch real-part spectra */
206 : const float specLi[], /* i : Lch imaginary-part input signal */
207 : const float specRr[], /* i : Rch real-part spectra */
208 : const float specRi[], /* i : Rch imaginary-part input signal */
209 : const int16_t input_frame /* i : input frame length per channel */
210 : )
211 : {
212 : int16_t i, n1, n2;
213 : int16_t n0, *itdLR;
214 : const float *s;
215 : float *P;
216 : float tmp1, tmp2, Lr, Li, Rr, Ri, gamma, igamma, iN;
217 :
218 : float specPOr[L_FRAME48k / 2 + 1], specPOi[L_FRAME48k / 2]; /*real and imaginary values for searching phase angle*/
219 : float tmpPOC1[L_FRAME48k], tmpPOC2[L_FRAME48k];
220 : float rfft_buf[L_FRAME48k];
221 : int16_t step, bias;
222 : int16_t mult_angle;
223 : int16_t j;
224 : int16_t end;
225 :
226 : int16_t cos_step, cos_max;
227 : float eps_cos, eps_sin, EPS;
228 :
229 : int16_t isd_cnt_h, isd_cnt_l, ild_cnt, n, freq_8k, freq_ipd_max, nsbd, input_frame_pha, pha_ipd_ild_chan2rephase;
230 : float Nr, Ni, Dr, Di, tPr, tPi, Pn, energy, isd_rate;
231 : float eneL, eneR, IPDr, IPDi, tIPDr, tIPDi, ICCr;
232 : float *Pr, *Pi, *ipd_ff, *p_curr_taps;
233 : float rfft_pha_buf[L_FRAME48k], tEr[STEREO_DMX_EVS_NB_SUBBAND_MAX], tEl[STEREO_DMX_EVS_NB_SUBBAND_MAX];
234 :
235 : /* Initialization */
236 8850 : iN = 1.0f / (float) input_frame;
237 8850 : s = hPOC->sin;
238 8850 : P = hPOC->P;
239 8850 : n0 = input_frame / 2;
240 8850 : itdLR = hPOC->itdLR;
241 :
242 8850 : Pr = hPHA->Pr;
243 8850 : Pi = hPHA->Pi;
244 8850 : nsbd = n0 / STEREO_DMX_EVS_SUBBAND_SIZE;
245 8850 : input_frame_pha = input_frame / STEREO_DMX_EVS_SUBBAND_SIZE;
246 :
247 8850 : igamma = STEREO_DMX_EVS_POC_GAMMA * iN;
248 8850 : gamma = 1.0f - igamma;
249 :
250 8850 : step = 1;
251 8850 : bias = 0;
252 8850 : cos_step = 2;
253 8850 : cos_max = n0;
254 8850 : mult_angle = 3;
255 :
256 8850 : if ( input_frame == L_FRAME16k )
257 : {
258 3000 : step = 3;
259 3000 : bias = 1;
260 3000 : cos_step = 4;
261 3000 : cos_max = input_frame;
262 3000 : mult_angle = 2; /*****/
263 : }
264 8850 : if ( input_frame == L_FRAME32k )
265 : {
266 2850 : mult_angle = 2;
267 : }
268 :
269 8850 : end = min( n0, 320 );
270 8850 : specPOr[0] = sign( specLr[0] * specRr[0] ) * wnd[bias];
271 8850 : specPOi[0] = 0.0f;
272 8850 : EPS = hPOC->eps;
273 8850 : if ( input_frame == L_FRAME48k )
274 : {
275 720000 : for ( i = 1; i < n0 / 2; i++ )
276 : {
277 717000 : eps_cos = s[cos_max - i * cos_step /*cos_max - i_for*/] * EPS;
278 717000 : eps_sin = s[i * cos_step /*i_for*/] * EPS;
279 717000 : Lr = specLr[i] + specRr[i] * eps_cos + specRi[i] * eps_sin;
280 717000 : Li = specLi[i] - specRr[i] * eps_sin + specRi[i] * eps_cos;
281 717000 : Rr = specRr[i] + specLr[i] * eps_cos + specLi[i] * eps_sin;
282 717000 : Ri = specRi[i] - specLr[i] * eps_sin + specLi[i] * eps_cos;
283 :
284 717000 : specPOr[i] = ( Lr * Rr + Li * Ri );
285 717000 : specPOi[i] = ( Lr * Ri - Li * Rr );
286 717000 : j = n0 - i;
287 717000 : if ( j < 320 )
288 : {
289 237000 : Lr = specLr[j] - specRr[j] * eps_cos + specRi[j] * eps_sin;
290 237000 : Li = specLi[j] - specRr[j] * eps_sin - specRi[j] * eps_cos;
291 237000 : Rr = specRr[j] - specLr[j] * eps_cos + specLi[j] * eps_sin;
292 237000 : Ri = specRi[j] - specLr[j] * eps_sin - specLi[j] * eps_cos;
293 :
294 237000 : specPOr[j] = ( Lr * Rr + Li * Ri );
295 237000 : specPOi[j] = ( Lr * Ri - Li * Rr );
296 : }
297 : }
298 : }
299 : else /* 16kHz and 32 kHz*/
300 : {
301 696000 : for ( i = 1; i < n0 / 2; i++ )
302 : {
303 690150 : eps_cos = s[cos_max - i * cos_step /*cos_max - i_for*/] * EPS;
304 690150 : eps_sin = s[i * cos_step /*i_for*/] * EPS;
305 :
306 690150 : Lr = specLr[i] + specRr[i] * eps_cos + specRi[i] * eps_sin;
307 690150 : Li = specLi[i] - specRr[i] * eps_sin + specRi[i] * eps_cos;
308 690150 : Rr = specRr[i] + specLr[i] * eps_cos + specLi[i] * eps_sin;
309 690150 : Ri = specRi[i] - specLr[i] * eps_sin + specLi[i] * eps_cos;
310 690150 : specPOr[i] = ( Lr * Rr + Li * Ri );
311 690150 : specPOi[i] = ( Lr * Ri - Li * Rr );
312 :
313 690150 : j = n0 - i;
314 690150 : Lr = specLr[j] - specRr[j] * eps_cos + specRi[j] * eps_sin;
315 690150 : Li = specLi[j] - specRr[j] * eps_sin - specRi[j] * eps_cos;
316 690150 : Rr = specRr[j] - specLr[j] * eps_cos + specLi[j] * eps_sin;
317 690150 : Ri = specRi[j] - specLr[j] * eps_sin - specLi[j] * eps_cos;
318 690150 : specPOr[j] = ( Lr * Rr + Li * Ri );
319 690150 : specPOi[j] = ( Lr * Ri - Li * Rr );
320 : }
321 : }
322 : {
323 : /* i=n0/2*/
324 8850 : Lr = specLr[i] + specRi[i] * EPS;
325 8850 : Li = specLi[i] - specRr[i] * EPS;
326 8850 : Rr = specRr[i] + specLi[i] * EPS;
327 8850 : Ri = specRi[i] - specLr[i] * EPS;
328 8850 : specPOr[i] = ( Lr * Rr + Li * Ri );
329 8850 : specPOi[i] = ( Lr * Ri - Li * Rr );
330 : }
331 : /* complex spectrum (specPOr[i], specPOi[i]) are placed on an unit circle without using srqt()*/
332 88500 : for ( i = 1; i < 10; i++ ) /*search from 4 angles */
333 : {
334 79650 : tmp1 = wnd[i * step + bias] * gamma;
335 :
336 79650 : specPOr[i] = sign( specPOr[i] ) * 0.866f * tmp1; /* low angles are more frequent for low frequency */
337 79650 : specPOi[i] = sign( specPOi[i] ) * 0.5f * tmp1;
338 79650 : gamma -= igamma;
339 : }
340 97350 : for ( ; i < n0 >> 4; i++ ) /*search from 4 angles */
341 : {
342 88500 : tmp1 = wnd[i * step + bias] * gamma * 0.7071f;
343 :
344 88500 : specPOr[i] = sign( specPOr[i] ) * tmp1;
345 88500 : specPOi[i] = sign( specPOi[i] ) * tmp1; /* low accuracy is adequate for low frequency */
346 88500 : gamma -= igamma;
347 : }
348 :
349 185850 : for ( ; i < n0 >> 3; i++ ) /* binary search from 8 angles */
350 : {
351 177000 : tmp1 = wnd[i * step + bias] * gamma;
352 :
353 177000 : if ( ( specPOr[i] - specPOi[i] ) * ( specPOr[i] + specPOi[i] ) > 0 )
354 : {
355 94302 : specPOr[i] = sign( specPOr[i] ) * tmp1 * /*0.923880f*/ s[120 * mult_angle]; /* cos(PI/8)*/
356 94302 : specPOi[i] = sign( specPOi[i] ) * tmp1 * /*0.382683f*/ s[40 * mult_angle];
357 : }
358 : else
359 : {
360 82698 : specPOr[i] = sign( specPOr[i] ) * tmp1 * /*0.382683f*/ s[40 * mult_angle]; /* cos(PI*3/8)*/
361 82698 : specPOi[i] = sign( specPOi[i] ) * tmp1 * /*0.923880f*/ s[120 * mult_angle];
362 : }
363 177000 : gamma -= igamma;
364 : }
365 2006850 : for ( ; i < end; i++ ) /* binary search from 16 angles */
366 : {
367 1998000 : tmp1 = wnd[i * step + bias] * gamma;
368 1998000 : if ( ( specPOr[i] - specPOi[i] ) * ( specPOr[i] + specPOi[i] ) > 0 )
369 : {
370 1047342 : if ( ( specPOr[i] * 0.414213f - specPOi[i] ) * ( specPOr[i] * 0.414213f + specPOi[i] ) > 0 ) /*tan(PI/8)*/
371 : {
372 563128 : specPOr[i] = sign( specPOr[i] ) * tmp1 /*0.980785f */ * s[140 * mult_angle]; /* cos(PI/16)*/
373 563128 : specPOi[i] = sign( specPOi[i] ) * tmp1 /*0.195090f */ * s[20 * mult_angle];
374 : }
375 : else
376 : {
377 484214 : specPOr[i] = sign( specPOr[i] ) * tmp1 /* 0.831470f */ * s[100 * mult_angle]; /*cos(PI*3/16)*/
378 484214 : specPOi[i] = sign( specPOi[i] ) * tmp1 /* 0.555570f*/ * s[60 * mult_angle];
379 : }
380 : }
381 : else
382 : {
383 950658 : if ( ( specPOr[i] - specPOi[i] * 0.414213f ) * ( specPOr[i] + specPOi[i] * 0.414213f ) > 0 ) /*tan(PI/8)*/
384 : {
385 476523 : specPOr[i] = sign( specPOr[i] ) * tmp1 /** 0.555570f*/ * s[60 * mult_angle]; /*cos(PI*5/16)*/
386 476523 : specPOi[i] = sign( specPOi[i] ) * tmp1 /** 0.831470f*/ * s[100 * mult_angle];
387 : }
388 : else
389 : {
390 474135 : specPOr[i] = sign( specPOr[i] ) * tmp1 /** 0.195090f*/ * s[20 * mult_angle]; /*cos(PI*7/16)*/
391 474135 : specPOi[i] = sign( specPOi[i] ) * tmp1 /** 0.980785f*/ * s[140 * mult_angle];
392 : }
393 : }
394 1998000 : gamma -= igamma;
395 : }
396 :
397 8850 : if ( i < n0 )
398 : {
399 3000 : gamma -= igamma * ( n0 - 320 );
400 : }
401 488850 : for ( ; i < n0; i++ ) /*neglect higher frequency bins when 48 kHz samplng*/
402 : {
403 480000 : specPOr[i] = 0.f;
404 480000 : specPOi[i] = 0.f;
405 : }
406 8850 : specPOr[n0] = sign( specLr[n0] * specRr[n0] ) * wnd[i * step + bias] * gamma;
407 :
408 8850 : freq_8k = L_FRAME16k / 2;
409 8850 : freq_ipd_max = (int16_t) ( freq_8k * 5000.0f / ( 8000.0f * STEREO_DMX_EVS_SUBBAND_SIZE ) );
410 :
411 : /* Memorize the filters N-1 */
412 26550 : for ( n = 0; n < CPE_CHANNELS; n++ )
413 : {
414 17700 : if ( hPHA->p_curr_taps[n] )
415 : {
416 17349 : hPHA->p_prev_taps[n] = hPHA->prev_taps[n];
417 17349 : mvr2r( hPHA->p_curr_taps[n], hPHA->p_prev_taps[n], hPHA->pha_len );
418 : }
419 : else
420 : {
421 351 : hPHA->p_prev_taps[n] = NULL;
422 : }
423 : }
424 :
425 : /* ISD */
426 8850 : isd_cnt_l = 0;
427 8850 : isd_cnt_h = 0;
428 1424850 : for ( i = 1; i <= freq_8k; i++ )
429 : {
430 1416000 : Nr = ( specLr[i] - specRr[i] );
431 1416000 : Ni = ( specLi[i] - specRi[i] );
432 1416000 : Dr = ( specLr[i] + specRr[i] );
433 1416000 : Di = ( specLi[i] + specRi[i] );
434 1416000 : if ( ( Nr * Nr + Ni * Ni ) > STEREO_DMX_EVS_ISD_THRES_H * ( Dr * Dr + Di * Di ) )
435 : {
436 460932 : isd_cnt_h++;
437 : }
438 1416000 : if ( ( Nr * Nr + Ni * Ni ) < STEREO_DMX_EVS_ISD_THRES_L * ( Dr * Dr + Di * Di ) )
439 : {
440 743891 : isd_cnt_l++;
441 : }
442 : }
443 :
444 8850 : isd_rate = (float) isd_cnt_h / (float) freq_8k;
445 8850 : hPHA->isd_rate_s = STEREO_DMX_EVS_ISD_FORGETTING * hPHA->isd_rate_s + ( 1.0f - STEREO_DMX_EVS_ISD_FORGETTING ) * isd_rate;
446 :
447 8850 : if ( hPHA->isd_rate_s > STEREO_DMX_EVS_ISD_DIST_HYST_H )
448 : {
449 0 : if ( hPHA->curr_pha != STEREO_DMX_EVS_PHA_IPD )
450 : {
451 0 : if ( hPHA->prev_pha == STEREO_DMX_EVS_PHA_IPD )
452 : {
453 0 : hPHA->pha_hys_cnt += 1;
454 : }
455 : else
456 : {
457 0 : hPHA->pha_hys_cnt = 0;
458 : }
459 :
460 0 : if ( hPHA->pha_hys_cnt >= STEREO_DMX_EVS_SWTCH_HYS_THRES )
461 : {
462 0 : hPHA->curr_pha = STEREO_DMX_EVS_PHA_IPD;
463 : }
464 : }
465 :
466 0 : hPHA->prev_pha = STEREO_DMX_EVS_PHA_IPD;
467 : }
468 8850 : else if ( hPHA->isd_rate_s < STEREO_DMX_EVS_ISD_DIST_HYST_L )
469 : {
470 7752 : if ( hPHA->curr_pha != STEREO_DMX_EVS_PHA_IPD2 )
471 : {
472 234 : if ( hPHA->prev_pha == STEREO_DMX_EVS_PHA_IPD2 )
473 : {
474 117 : hPHA->pha_hys_cnt += 1;
475 : }
476 : else
477 : {
478 117 : hPHA->pha_hys_cnt = 0;
479 : }
480 :
481 234 : if ( hPHA->pha_hys_cnt >= STEREO_DMX_EVS_SWTCH_HYS_THRES )
482 : {
483 117 : hPHA->curr_pha = STEREO_DMX_EVS_PHA_IPD2;
484 : }
485 : }
486 7752 : hPHA->prev_pha = STEREO_DMX_EVS_PHA_IPD2;
487 : }
488 :
489 8850 : ipd_ff = hPHA->ipd_ff;
490 :
491 8850 : Nr = 0;
492 8850 : Ni = 0;
493 8850 : eneL = 0;
494 8850 : eneR = 0;
495 8850 : step = n0 >> 3;
496 8850 : tmp1 = 0.0f;
497 8850 : tmp2 = 0.0f;
498 1416000 : for ( n = 1, i = 1; n < nsbd; n++ )
499 : {
500 1407150 : tPr = 0.0f;
501 1407150 : tPi = 0.0f;
502 1407150 : tEr[n] = 0.0f;
503 1407150 : tEl[n] = 0.0f;
504 :
505 4221450 : for ( j = 0; j < STEREO_DMX_EVS_SUBBAND_SIZE; j++, i++ )
506 : {
507 : /* Energy */
508 2814300 : tEl[n] += specLr[i] * specLr[i] + specLi[i] * specLi[i];
509 2814300 : tEr[n] += specRr[i] * specRr[i] + specRi[i] * specRi[i];
510 :
511 : /* IPD */
512 2814300 : IPDr = specLr[i] * specRr[i] + specLi[i] * specRi[i];
513 2814300 : IPDi = specLi[i] * specRr[i] - specLr[i] * specRi[i];
514 2814300 : tPr += IPDr;
515 2814300 : tPi += IPDi;
516 :
517 : /* ICCr */
518 2814300 : Pn = inv_sqrtf( ( IPDr * IPDr + IPDi * IPDi ) + EPSILON );
519 2814300 : IPDr *= Pn;
520 2814300 : IPDi *= Pn;
521 :
522 2814300 : tIPDr = ( specRr[i] * IPDr - specRi[i] * IPDi );
523 2814300 : tIPDi = ( specRr[i] * IPDi + specRi[i] * IPDr );
524 :
525 2814300 : Nr += ( specLr[i] * tIPDr + specLi[i] * tIPDi );
526 2814300 : Ni += ( specLi[i] * tIPDr - specLr[i] * tIPDi );
527 :
528 2814300 : eneL += ( specLr[i] * specLr[i] + specLi[i] * specLi[i] );
529 2814300 : eneR += ( specRr[i] * specRr[i] + specRi[i] * specRi[i] );
530 :
531 2814300 : if ( i == step - 1 )
532 : {
533 8850 : tmp1 = eneL;
534 8850 : tmp2 = eneR;
535 : }
536 : }
537 1407150 : Pn = inv_sqrtf( ( tPr * tPr + tPi * tPi ) + EPSILON );
538 :
539 1407150 : tPr *= Pn;
540 1407150 : tPi *= Pn;
541 :
542 1407150 : Pr[n] = ipd_ff[n] * Pr[n] + ( 1.0f - ipd_ff[n] ) * tPr;
543 1407150 : Pi[n] = ipd_ff[n] * Pi[n] + ( 1.0f - ipd_ff[n] ) * tPi;
544 1407150 : Pn = inv_sqrtf( ( Pr[n] * Pr[n] + Pi[n] * Pi[n] ) + EPSILON );
545 1407150 : Pr[n] *= Pn;
546 1407150 : Pi[n] *= Pn;
547 :
548 1407150 : Pr[n] = ( Pr[n] > 1.0f ) ? 1.0f : Pr[n];
549 1407150 : Pr[n] = ( Pr[n] < -1.0f ) ? -1.0f : Pr[n];
550 : }
551 :
552 : /* Computes Spectral flatness on one channel */
553 8850 : if ( spectral_flatness( &tEl[1], nsbd - 1 ) < hPHA->pha_ipd_sf_Threshold )
554 : {
555 7269 : hPHA->pha_ipd_chanswitch_allowed = 0;
556 : }
557 : else
558 : {
559 1581 : hPHA->pha_ipd_chanswitch_allowed = 1;
560 : }
561 :
562 8850 : ICCr = sqrtf( ( Nr * Nr + Ni * Ni ) / ( eneL * eneR + EPSILON ) );
563 8850 : hPHA->iccr_s = STEREO_DMX_EVS_ICCR_FORGETTING * hPHA->iccr_s + ( 1.0f - STEREO_DMX_EVS_ICCR_FORGETTING ) * ICCr;
564 :
565 8850 : eneL -= tmp1;
566 8850 : eneR -= tmp2;
567 :
568 8850 : IPDr = cosf( hPHA->phitd * step );
569 8850 : IPDi = sinf( hPHA->phitd * step );
570 8850 : tmp1 = cosf( hPHA->phitd );
571 8850 : tmp2 = sinf( hPHA->phitd );
572 :
573 2478000 : for ( Nr = 0, Ni = 0, i = step; i < ( n0 - 1 ); i++ )
574 : {
575 2469150 : tIPDr = ( specRr[i] * IPDr + specRi[i] * IPDi );
576 2469150 : tIPDi = ( specRr[i] * IPDi - specRi[i] * IPDr );
577 2469150 : Nr += ( specLr[i] * tIPDr - specLi[i] * tIPDi );
578 2469150 : Ni += ( specLi[i] * tIPDr + specLr[i] * tIPDi );
579 2469150 : tIPDr = IPDr;
580 2469150 : IPDr = tIPDr * tmp1 - IPDi * tmp2;
581 2469150 : IPDi = tIPDr * tmp2 + IPDi * tmp1;
582 : }
583 :
584 8850 : if ( ICCr == 0.f )
585 : {
586 0 : ICCr = 1;
587 : }
588 8850 : ICCr = 0.5f * ( ICCr + ( sqrtf( ( Nr * Nr + Ni * Ni ) / ( eneL * eneR + EPSILON ) ) ) );
589 8850 : hPHA->iccres_s = STEREO_DMX_EVS_ICCRES_FORGETTING * hPHA->iccres_s + ( 1.0f - STEREO_DMX_EVS_ICCRES_FORGETTING ) * ICCr;
590 :
591 8850 : if ( hPHA->curr_pha == STEREO_DMX_EVS_PHA_IPD )
592 : {
593 117 : hPHA->force_poc = FALSE;
594 117 : hPHA->proc_pha = STEREO_DMX_EVS_PHA_IPD;
595 : }
596 : else
597 : {
598 8733 : if ( ( hPHA->iccr_s < STEREO_DMX_EVS_ICCR_HYST_L ) || ( ( hPHA->iccr_s < STEREO_DMX_EVS_ICCR_HYST_H ) && ( hPHA->proc_pha == STEREO_DMX_EVS_PHA_IPD2 ) && !hPHA->force_poc ) )
599 : {
600 1323 : hPHA->force_poc = FALSE;
601 1323 : hPHA->proc_pha = STEREO_DMX_EVS_PHA_IPD2;
602 : }
603 : else
604 : {
605 7410 : hPHA->force_poc = TRUE;
606 : }
607 : }
608 :
609 8850 : if ( hPHA->proc_pha == STEREO_DMX_EVS_PHA_IPD )
610 : {
611 117 : rfft_pha_buf[0] = 1.;
612 117 : rfft_pha_buf[1] = 1.;
613 :
614 117 : ild_cnt = 0;
615 15520 : for ( i = 1; i < nsbd; i++ )
616 : {
617 15403 : rfft_pha_buf[i * 2] = Pr[i];
618 15403 : rfft_pha_buf[i * 2 + 1] = Pi[i];
619 15403 : if ( ( tEr[i] > STEREO_DMX_EVS_LR_EGY * tEl[i] ) || ( tEl[i] > STEREO_DMX_EVS_LR_EGY * tEr[i] ) )
620 : {
621 687 : ild_cnt++;
622 687 : tEr[i] = 1;
623 : }
624 : else
625 : {
626 14716 : tEr[i] = -1;
627 : }
628 : }
629 117 : if ( ild_cnt > nsbd * STEREO_DMX_EVS_ILD_PRC )
630 : {
631 0 : for ( i = 1; i < nsbd; i++ )
632 : {
633 0 : if ( tEr[i] > 0 )
634 : {
635 0 : rfft_pha_buf[i * 2] = 1.;
636 0 : rfft_pha_buf[i * 2 + 1] = 0.;
637 : }
638 : }
639 : }
640 :
641 117 : rfft( rfft_pha_buf, hPHA->rfft_ipd_coef, input_frame_pha, +1 );
642 :
643 : /* Choose best channel to phase align */
644 : /* Channel selection based on ILD */
645 117 : if ( hPHA->trns_aux_energy[0] > hPHA->trns_aux_energy[1] * hPHA->pha_ipd_ild_thresh )
646 : {
647 0 : pha_ipd_ild_chan2rephase = 1;
648 : }
649 117 : else if ( hPHA->trns_aux_energy[1] > hPHA->trns_aux_energy[0] * hPHA->pha_ipd_ild_thresh )
650 : {
651 0 : pha_ipd_ild_chan2rephase = 0;
652 : }
653 : else
654 : {
655 117 : pha_ipd_ild_chan2rephase = -1;
656 : }
657 :
658 : /* Channel selection based on spikyness of R2L/L2R impulse responses */
659 117 : tmp1 = spectral_flatness( rfft_pha_buf, hPHA->pha_len );
660 117 : rfft_pha_buf[input_frame_pha - hPHA->pha_len] = rfft_pha_buf[0];
661 117 : tmp2 = spectral_flatness( &rfft_pha_buf[input_frame_pha - hPHA->pha_len], hPHA->pha_len );
662 :
663 : /* Combined ILD/SF channel selection with tempo */
664 117 : if ( ( ( tmp1 > tmp2 ) && ( pha_ipd_ild_chan2rephase == -1 ) ) || ( pha_ipd_ild_chan2rephase == 0 ) ) /* L => R */
665 : {
666 0 : if ( hPHA->pha_ipd_previouschan2rephase == 0 )
667 : {
668 0 : hPHA->pha_ipd_chan_cnt++;
669 0 : if ( hPHA->pha_ipd_chan_cnt >= hPHA->pha_ipd_chan_thresh )
670 : {
671 : /* Avoid channel switch in case of too harmonic signals */
672 0 : if ( hPHA->pha_ipd_chanswitch_allowed )
673 : {
674 0 : if ( hPHA->pha_ipd_chan2rephase != 0 )
675 : {
676 0 : hPHA->pha_ipd_chanswitch = 1;
677 : }
678 : else
679 : {
680 0 : hPHA->pha_ipd_chanswitch = 0;
681 : }
682 0 : hPHA->pha_ipd_chan2rephase = 0;
683 : }
684 : }
685 : }
686 : else
687 : {
688 0 : hPHA->pha_ipd_previouschan2rephase = 0;
689 0 : hPHA->pha_ipd_chan_cnt = 1;
690 0 : hPHA->pha_ipd_chanswitch = 0;
691 : }
692 : }
693 : else /* R => L */
694 : {
695 117 : if ( hPHA->pha_ipd_previouschan2rephase == 1 )
696 : {
697 117 : hPHA->pha_ipd_chan_cnt++;
698 117 : if ( hPHA->pha_ipd_chan_cnt >= hPHA->pha_ipd_chan_thresh )
699 : {
700 : /* Avoid channel switch in case of too harmonic signals */
701 0 : if ( hPHA->pha_ipd_chanswitch_allowed )
702 : {
703 0 : if ( hPHA->pha_ipd_chan2rephase != 1 )
704 : {
705 0 : hPHA->pha_ipd_chanswitch = 1;
706 : }
707 : else
708 : {
709 0 : hPHA->pha_ipd_chanswitch = 0;
710 : }
711 0 : hPHA->pha_ipd_chan2rephase = 1;
712 : }
713 0 : hPHA->pha_ipd_chan_cnt = hPHA->pha_ipd_chan_thresh;
714 : }
715 : }
716 : else
717 : {
718 0 : hPHA->pha_ipd_previouschan2rephase = 1;
719 0 : hPHA->pha_ipd_chan_cnt = 1;
720 0 : hPHA->pha_ipd_chanswitch = 0;
721 : }
722 : }
723 :
724 117 : if ( !hPHA->pha_ipd_chanswitch )
725 : {
726 117 : if ( hPHA->pha_ipd_chan2rephase == 0 )
727 : {
728 0 : hPHA->p_curr_taps[1] = NULL;
729 0 : hPHA->p_curr_taps[0] = hPHA->curr_taps[0];
730 0 : p_curr_taps = hPHA->p_curr_taps[0];
731 0 : p_curr_taps[0] = rfft_pha_buf[0];
732 0 : for ( i = 1, j = input_frame_pha - 1; i < hPHA->pha_len; i++, j-- )
733 : {
734 0 : p_curr_taps[i] = rfft_pha_buf[j];
735 : }
736 : }
737 : else
738 : {
739 117 : hPHA->p_curr_taps[0] = NULL;
740 117 : hPHA->p_curr_taps[1] = hPHA->curr_taps[1];
741 117 : mvr2r( rfft_pha_buf, hPHA->p_curr_taps[1], hPHA->pha_len );
742 : }
743 : }
744 : }
745 :
746 8850 : if ( hPHA->pha_ipd_chanswitch )
747 : {
748 0 : for ( n = 0; n < CPE_CHANNELS; n++ )
749 : {
750 0 : hPHA->p_curr_taps[n] = NULL;
751 : }
752 : }
753 8850 : else if ( hPHA->proc_pha == STEREO_DMX_EVS_PHA_IPD2 )
754 : {
755 : /* IPDn */
756 :
757 8733 : set_f( &( Pr[freq_ipd_max] ), 1.0f, ( nsbd - freq_ipd_max ) );
758 8733 : set_f( &( Pi[freq_ipd_max] ), 0.0f, ( nsbd - freq_ipd_max ) );
759 :
760 26199 : for ( n = 0; n < CPE_CHANNELS; n++ )
761 : {
762 17466 : hPHA->p_curr_taps[n] = hPHA->curr_taps[n];
763 : }
764 :
765 8733 : rfft_pha_buf[0] = 1.;
766 8733 : rfft_pha_buf[1] = 1.;
767 :
768 8733 : ild_cnt = 0;
769 8733 : isd_rate = (float) isd_cnt_l / freq_8k;
770 1400480 : for ( i = 1; i < nsbd; i++ )
771 : {
772 1391747 : rfft_pha_buf[i * 2] = sqrtf( ( 1.0f + Pr[i] ) / 2.0f );
773 1391747 : rfft_pha_buf[i * 2 + 1] = sqrtf( ( 1.0f - Pr[i] ) / 2.0f ) * sign( Pi[i] );
774 1391747 : if ( isd_rate > STEREO_DMX_EVS_ISD_DIST_THRES_IPD )
775 : {
776 728270 : rfft_pha_buf[i * 2 + 1] = sqrtf( ( 1.0f - rfft_pha_buf[i * 2] ) / 2.0f ) * sign( rfft_pha_buf[i * 2 + 1] );
777 728270 : rfft_pha_buf[i * 2] = sqrtf( ( 1.0f + rfft_pha_buf[i * 2] ) / 2.0f );
778 : }
779 1391747 : if ( ( tEr[i] > STEREO_DMX_EVS_LR_EGY * tEl[i] ) || ( tEl[i] > STEREO_DMX_EVS_LR_EGY * tEr[i] ) )
780 : {
781 87417 : ild_cnt++;
782 87417 : tEr[i] = 1;
783 : }
784 : else
785 : {
786 1304330 : tEr[i] = -1;
787 : }
788 : }
789 8733 : if ( ild_cnt > nsbd * STEREO_DMX_EVS_ILD_PRC )
790 : {
791 155680 : for ( i = 1; i < nsbd; i++ )
792 : {
793 154940 : if ( tEr[i] > 0 )
794 : {
795 43422 : rfft_pha_buf[i * 2] = 1.;
796 43422 : rfft_pha_buf[i * 2 + 1] = 0.;
797 : }
798 : }
799 : }
800 :
801 8733 : rfft( rfft_pha_buf, hPHA->rfft_ipd_coef, input_frame_pha, +1 );
802 8733 : mvr2r( rfft_pha_buf, hPHA->p_curr_taps[1], hPHA->pha_len );
803 :
804 : /* PHA L2R */
805 8733 : p_curr_taps = hPHA->p_curr_taps[0];
806 8733 : p_curr_taps[0] = rfft_pha_buf[0];
807 348624 : for ( i = 1; i < hPHA->pha_len; i++ )
808 : {
809 339891 : p_curr_taps[i] = rfft_pha_buf[input_frame_pha - i];
810 : }
811 : }
812 :
813 26550 : for ( n = 0; n < CPE_CHANNELS; n++ )
814 : {
815 17700 : if ( hPHA->p_curr_taps[n] )
816 : {
817 719007 : for ( i = 0; i < hPHA->pha_len; i++ )
818 : {
819 701424 : hPHA->p_curr_taps[n][i] *= hPHA->win[i];
820 : }
821 :
822 17583 : energy = 0.;
823 719007 : for ( i = 0; i < hPHA->pha_len; i++ )
824 : {
825 701424 : energy += hPHA->p_curr_taps[n][i] * hPHA->p_curr_taps[n][i];
826 : }
827 17583 : energy = inv_sqrtf( energy + EPSILON );
828 719007 : for ( i = 0; i < hPHA->pha_len; i++ )
829 : {
830 701424 : hPHA->p_curr_taps[n][i] *= energy;
831 : }
832 : }
833 : }
834 :
835 :
836 8850 : rfft_buf[0] = specPOr[0];
837 8850 : rfft_buf[1] = specPOr[n0];
838 2832000 : for ( i = 1; i < n0; i++ )
839 : {
840 2823150 : rfft_buf[i * 2] = specPOr[i];
841 2823150 : rfft_buf[i * 2 + 1] = specPOi[i];
842 : }
843 :
844 8850 : rfft( rfft_buf, rfft_coef, input_frame, +1 );
845 :
846 8850 : tmp1 = rfft_buf[0];
847 8850 : tmpPOC1[n0] = tmp1 * tmp1;
848 :
849 1601850 : for ( i = 1; i < hPOC->shift_limit + 1; i++ )
850 : {
851 1593000 : n1 = n0 + i;
852 1593000 : n2 = n0 - i;
853 :
854 1593000 : tmp1 = rfft_buf[i];
855 1593000 : tmpPOC1[n1] = tmp1 * tmp1;
856 :
857 1593000 : tmp1 = rfft_buf[input_frame - i];
858 1593000 : tmpPOC1[n2] = tmp1 * tmp1;
859 : }
860 :
861 8850 : tmp1 = STEREO_DMX_EVS_POC_SMOOTH * tmpPOC1[n0] + 0.5f * ( 1.0f - STEREO_DMX_EVS_POC_SMOOTH ) * ( tmpPOC1[n0 - 1] + tmpPOC1[n0 + 1] );
862 8850 : tmpPOC2[n0] = max( tmp1, 0.0f );
863 :
864 1593000 : for ( i = 1; i < hPOC->shift_limit; i++ )
865 : {
866 1584150 : n1 = n0 + i;
867 1584150 : n2 = n0 - i;
868 1584150 : tmp1 = STEREO_DMX_EVS_POC_SMOOTH * tmpPOC1[n1] + 0.5f * ( 1.0f - STEREO_DMX_EVS_POC_SMOOTH ) * ( tmpPOC1[n1 - 1] + tmpPOC1[n1 + 1] );
869 1584150 : tmp2 = STEREO_DMX_EVS_POC_SMOOTH * tmpPOC1[n2] + 0.5f * ( 1.0f - STEREO_DMX_EVS_POC_SMOOTH ) * ( tmpPOC1[n2 - 1] + tmpPOC1[n2 + 1] );
870 1584150 : tmpPOC2[n1] = max( tmp1, 0.0f );
871 1584150 : tmpPOC2[n2] = max( tmp2, 0.0f );
872 : }
873 :
874 8850 : P[n0] = P[n0] * STEREO_DMX_EVS_POC_FORGETTING + tmpPOC2[n0] * ( 1.0f - STEREO_DMX_EVS_POC_FORGETTING );
875 :
876 1593000 : for ( i = 1; i < hPOC->shift_limit; i++ )
877 : {
878 1584150 : n1 = n0 + i;
879 1584150 : n2 = n0 - i;
880 :
881 1584150 : if ( i == -itdLR[1] )
882 : {
883 1486 : P[n1] = P[n1] * STEREO_DMX_EVS_TARGET_POC_FORGETTING + tmpPOC2[n1] * ( 1.0f - STEREO_DMX_EVS_TARGET_POC_FORGETTING );
884 : }
885 : else
886 : {
887 1582664 : P[n1] = P[n1] * STEREO_DMX_EVS_POC_FORGETTING + tmpPOC2[n1] * ( 1.0f - STEREO_DMX_EVS_POC_FORGETTING );
888 : }
889 :
890 1584150 : if ( i == itdLR[0] )
891 : {
892 3333 : P[n2] = P[n2] * STEREO_DMX_EVS_TARGET_POC_FORGETTING + tmpPOC2[n2] * ( 1.0f - STEREO_DMX_EVS_TARGET_POC_FORGETTING );
893 : }
894 : else
895 : {
896 1580817 : P[n2] = P[n2] * STEREO_DMX_EVS_POC_FORGETTING + tmpPOC2[n2] * ( 1.0f - STEREO_DMX_EVS_POC_FORGETTING );
897 : }
898 : }
899 :
900 8850 : return;
901 : }
902 :
903 :
904 : /*-------------------------------------------------------------------*
905 : * find_poc_peak()
906 : *
907 : * find peak phase only correlation
908 : *-------------------------------------------------------------------*/
909 :
910 8850 : static float find_poc_peak(
911 : STEREO_DMX_EVS_POC_HANDLE hPOC, /* i/o: phase only correlation structure */
912 : float itd[], /* o : estimated itd */
913 : const int16_t input_frame, /* i : input frame length per channel */
914 : const float ratio /* i : adapting ratio */
915 : )
916 : {
917 : int16_t itd_cand[CPE_CHANNELS], i, n, cnt[CPE_CHANNELS], Lh, peak_range, *on, *itdLR, prev_off[CPE_CHANNELS];
918 : float Q[CPE_CHANNELS], aQ[CPE_CHANNELS], cQ[CPE_CHANNELS], width, eps, cconfidence, *peak_width, *peakQ;
919 : float *P, tmpf;
920 : float eps2;
921 :
922 : /* Initialization */
923 8850 : Lh = input_frame / 2;
924 8850 : on = hPOC->ispeak;
925 8850 : itdLR = hPOC->itdLR;
926 8850 : width = 0.38f;
927 8850 : eps = 1.0f / (float) input_frame;
928 8850 : peak_width = hPOC->peak_width;
929 8850 : peakQ = hPOC->peakQ;
930 8850 : Q[0] = hPOC->P[Lh];
931 8850 : Q[1] = 0.0f;
932 8850 : itd_cand[0] = itd_cand[1] = 0;
933 8850 : P = hPOC->P;
934 :
935 1593000 : for ( i = 1; i < hPOC->shift_limit; i++ ) /*find peaks of POC P[] with positive and negative ITD */
936 : {
937 1584150 : if ( P[Lh - i] > Q[0] )
938 : {
939 30908 : Q[0] = P[Lh - i];
940 30908 : itd_cand[0] = i;
941 : }
942 1584150 : if ( P[Lh + i] > Q[1] )
943 : {
944 34790 : Q[1] = P[Lh + i];
945 34790 : itd_cand[1] = -i;
946 : }
947 : }
948 :
949 26550 : for ( n = 0; n < CPE_CHANNELS; n++ )
950 : {
951 17700 : prev_off[n] = !on[n];
952 :
953 17700 : aQ[n] = Q[n] * width;
954 17700 : cnt[n] = 0;
955 17700 : cQ[n] = P[Lh - itd_cand[n]];
956 :
957 17700 : peak_range = (int16_t) ( abs( itd_cand[n] ) + hPOC->shift_limit / STEREO_DMX_EVS_FIND_POC_PEAK_TAU ) / STEREO_DMX_EVS_FIND_POC_PEAK_TAU2;
958 :
959 167547 : for ( i = 1; i <= peak_range; i++ )
960 : {
961 149847 : cnt[n] += ( P[Lh - itd_cand[n] + i] > aQ[n] ) + ( P[Lh - itd_cand[n] - i] > aQ[n] );
962 149847 : cQ[n] += P[Lh - itd_cand[n] + i] + P[Lh - itd_cand[n] - i];
963 : }
964 :
965 17700 : peak_width[n] = peak_width[n] * ratio + (float) cnt[n] * ( 1.0f - ratio );
966 17700 : eps2 = eps * peak_width[n] * 0.25f;
967 17700 : Q[n] = ( 1.0f - ( cQ[n] / ( peak_range * 2 + 1 ) + eps2 ) / ( Q[n] + eps2 ) );
968 17700 : Q[n] = max( Q[n], 0.0f );
969 :
970 17700 : if ( on[n] ) /*if channel n was active (likely to be preceding) in the previous frame*/
971 : {
972 5482 : tmpf = ( 0.3f - 0.2f * (float) abs( itd_cand[n] ) / (float) hPOC->shift_limit ) * peakQ[n];
973 5482 : if ( Q[n] < tmpf )
974 : {
975 22 : itdLR[n] = 0;
976 22 : on[n] = 0;
977 22 : peakQ[n] = 0.0f;
978 22 : Q[n] = 0.0f;
979 : }
980 5460 : else if ( Q[n] > 1.25f * peakQ[n] )
981 : {
982 159 : itdLR[n] = itd_cand[n];
983 : }
984 :
985 5482 : peakQ[n] = max( peakQ[n], Q[n] );
986 : }
987 : else /*if channel n was not active (not likely to be preceding) in the previous frame*/
988 : {
989 12218 : tmpf = ( 0.75f - 0.2f * (float) abs( itd_cand[n] ) / (float) hPOC->shift_limit );
990 :
991 12218 : if ( Q[n] < tmpf )
992 : {
993 12059 : itdLR[n] = 0;
994 12059 : Q[n] = 0.0f;
995 : }
996 : else
997 : {
998 159 : itdLR[n] = itd_cand[n];
999 159 : on[n] = 1;
1000 : }
1001 : }
1002 : }
1003 :
1004 8850 : if ( ( on[0] && prev_off[0] ) && ( on[1] && prev_off[1] ) ) /*if both channels have newly detected as active (possibility of preceding), select channel by peakness Q[] of POC */
1005 : {
1006 0 : *itd = ( Q[0] > Q[1] ) ? (float) itdLR[0] : (float) itdLR[1];
1007 : }
1008 8850 : else if ( ( on[0] && prev_off[0] ) && ( Q[0] > ( Q[1] - 0.1 ) ) ) /* if channel 0 becomes active, select channel 0*/
1009 : {
1010 110 : *itd = (float) itdLR[0];
1011 : }
1012 8740 : else if ( ( on[1] && prev_off[1] ) && ( Q[1] > ( Q[0] - 0.1 ) ) ) /*if channel 1 becomes active, selsect channel 1*/
1013 : {
1014 45 : *itd = (float) itdLR[1];
1015 : }
1016 8695 : else if ( Q[0] > ( Q[1] + Q_BAND ) ) /* if no status change, use Q[]*/
1017 : {
1018 3126 : *itd = (float) itdLR[0];
1019 : }
1020 5569 : else if ( Q[1] > ( Q[0] + Q_BAND ) ) /* if no status change, use Q[]*/
1021 : {
1022 565 : *itd = (float) itdLR[1];
1023 : }
1024 5004 : else if ( *itd == 0.0 ) /*if no channels are likely to be preceding, follow the status of the previous frame*/
1025 : {
1026 4408 : *itd = 0;
1027 : }
1028 : else /*follow the status of the previous frame*/
1029 : {
1030 596 : *itd = ( *itd > 0 ) ? (float) itdLR[0] : (float) itdLR[1];
1031 : }
1032 :
1033 8850 : cconfidence = sqrtf( fabsf( Q[0] - Q[1] ) ); /*higher value indicates higher confidence for one preceding channel*/
1034 :
1035 8850 : return hPOC->confidence = hPOC->confidence * STEREO_DMX_EVS_CORR_FORGETTING + cconfidence * ( 1.0f - STEREO_DMX_EVS_CORR_FORGETTING );
1036 : }
1037 :
1038 :
1039 : /*-------------------------------------------------------------------*
1040 : * estimate_itd()
1041 : *
1042 : * estimate itd
1043 : *-------------------------------------------------------------------*/
1044 :
1045 8850 : static ivas_error estimate_itd(
1046 : float *corr, /* o : correlation */
1047 : STEREO_DMX_EVS_POC_HANDLE hPOC, /* i/o: phase only correlation structure */
1048 : STEREO_DMX_EVS_PHA_HANDLE hPHA, /* i/o: correlation filter structure */
1049 : const float srcL[], /* i : Lch input signal */
1050 : const float srcR[], /* i : Rch input signal */
1051 : float itd[], /* o : estimated itd */
1052 : const int16_t input_frame /* i : input frame length per channel */
1053 : )
1054 : {
1055 : float specLr[L_FRAME48k / 2 + 1], specLi[L_FRAME48k / 2 + 1], specRr[L_FRAME48k / 2 + 1], specRi[L_FRAME48k / 2 + 1];
1056 : float rfft_coef[L_FRAME48k];
1057 : const float *p_w;
1058 : int16_t n, n0, n1;
1059 : int16_t rfft_coef_step;
1060 : ivas_error error;
1061 :
1062 8850 : error = IVAS_ERR_OK;
1063 :
1064 8850 : n0 = input_frame >> 1;
1065 8850 : n1 = input_frame >> 2;
1066 :
1067 8850 : if ( input_frame == L_FRAME16k )
1068 : {
1069 3000 : p_w = dft_trigo_32k;
1070 3000 : rfft_coef_step = 4;
1071 : }
1072 5850 : else if ( input_frame == L_FRAME32k )
1073 : {
1074 2850 : p_w = dft_trigo_32k;
1075 2850 : rfft_coef_step = 2;
1076 : }
1077 3000 : else if ( input_frame == L_FRAME48k )
1078 : {
1079 3000 : p_w = dft_trigo_48k;
1080 3000 : rfft_coef_step = 2;
1081 : }
1082 : else
1083 : {
1084 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "failed estimate_itd()\n" );
1085 : }
1086 :
1087 1424850 : for ( n = 0; n < n1; n++ )
1088 : {
1089 1416000 : rfft_coef[n] = p_w[n * rfft_coef_step];
1090 1416000 : rfft_coef[n0 - n] = p_w[n * rfft_coef_step];
1091 : }
1092 8850 : rfft_coef[n1] = p_w[n1 * rfft_coef_step];
1093 :
1094 8850 : estimate_itd_wnd_fft( srcL, specLr, specLi, rfft_coef, hPOC->wnd, input_frame );
1095 8850 : estimate_itd_wnd_fft( srcR, specRr, specRi, rfft_coef, hPOC->wnd, input_frame );
1096 :
1097 8850 : calc_poc( hPOC, hPHA, hPOC->wnd, rfft_coef, specLr, specLi, specRr, specRi, input_frame );
1098 8850 : *corr = find_poc_peak( hPOC, itd, input_frame, STEREO_DMX_EVS_POC_W_FORGETTING );
1099 :
1100 8850 : return error;
1101 : }
1102 :
1103 :
1104 : /*-------------------------------------------------------------------*
1105 : * weighted_ave()
1106 : *
1107 : * create weighted downmix signal
1108 : *-------------------------------------------------------------------*/
1109 :
1110 8850 : static void weighted_ave(
1111 : const float src1[], /* i : Lch input signal */
1112 : const float src2[], /* i : Rch input signal */
1113 : float dst[], /* o : output signal */
1114 : const float gain, /* i : adapting gain */
1115 : const float old_gain, /* i : adapting prev gain */
1116 : const int16_t input_frame, /* i : input frame length per channel */
1117 : const float wnd[] /* i : window coef */
1118 : )
1119 : {
1120 :
1121 :
1122 : int16_t i, len, len2;
1123 8850 : float gain_tmp = 0.f, gain_sub;
1124 :
1125 8850 : len = input_frame >> 1;
1126 8850 : len2 = input_frame >> 2;
1127 8850 : gain_sub = gain - old_gain;
1128 :
1129 1424850 : for ( i = 0; i < len2; i++ )
1130 : {
1131 1416000 : gain_tmp = old_gain + gain_sub * wnd[i];
1132 1416000 : dst[i] = src1[i] * gain_tmp + src2[i] * ( 1.0f - gain_tmp );
1133 : }
1134 1424850 : for ( ; i < len; i++ )
1135 : {
1136 1416000 : gain_tmp = old_gain + gain_sub * ( 1.0f - wnd[len - i - 1] );
1137 1416000 : dst[i] = src1[i] * gain_tmp + src2[i] * ( 1.0f - gain_tmp );
1138 : }
1139 2840850 : for ( ; i < input_frame; i++ )
1140 : {
1141 2832000 : dst[i] = src1[i] * gain + src2[i] * ( 1.0f - gain_tmp );
1142 : }
1143 :
1144 :
1145 8850 : return;
1146 : }
1147 :
1148 : /*-------------------------------------------------------------------*
1149 : * spectral_flatness()
1150 : *
1151 : * computes spectral flatness SF
1152 : * SF(x) = exp(mean_i(ln(x_i))) / mean_i(x_i)
1153 : *-------------------------------------------------------------------*/
1154 :
1155 9084 : static float spectral_flatness(
1156 : const float sig[], /* i : input signal */
1157 : const int16_t sigLength /* i : input signal length */
1158 : )
1159 : {
1160 9084 : float geoMean = 0.0f;
1161 9084 : float ariMean = 0.0f;
1162 9084 : float eps = 1e-10f;
1163 : int16_t i;
1164 :
1165 : /* Initialization */
1166 1424586 : for ( i = 0; i < sigLength; i++ )
1167 : {
1168 1415502 : ariMean += fabsf( sig[i] ) + eps;
1169 1415502 : geoMean += logf( fabsf( sig[i] ) + eps );
1170 : }
1171 9084 : ariMean /= sigLength;
1172 9084 : geoMean /= sigLength;
1173 9084 : geoMean = expf( geoMean );
1174 :
1175 9084 : return geoMean / ariMean;
1176 : }
1177 :
1178 :
1179 : /*-------------------------------------------------------------------*
1180 : * calc_energy()
1181 : *
1182 : * calculate energy
1183 : *-------------------------------------------------------------------*/
1184 26550 : static void calc_energy(
1185 : const float src1[], /* i : Lch input signal */
1186 : const float src2[], /* i : Rch input signal */
1187 : float energy[], /* o : calculated energy */
1188 : float *lvl, /* o : calculated rms level */
1189 : const int16_t input_frame, /* i : input frame length per channel */
1190 : const float ratio /* i : adapting ratio */
1191 : )
1192 : {
1193 : float E, wnd, wnd_diff, lvli, lvlff;
1194 : int16_t i, adaptlen;
1195 :
1196 : /* Initialization */
1197 26550 : E = 0.0f;
1198 26550 : adaptlen = input_frame >> 4;
1199 26550 : wnd = 0.5f / (float) adaptlen;
1200 26550 : wnd_diff = 1.0f / (float) adaptlen;
1201 :
1202 1088550 : for ( i = 0; i < adaptlen; i++ )
1203 : {
1204 1062000 : E += ( src1[i] * wnd ) * ( src2[i] * wnd );
1205 :
1206 1062000 : wnd += wnd_diff;
1207 : }
1208 14894550 : for ( ; i < input_frame - adaptlen; i++ )
1209 : {
1210 14868000 : E += src1[i] * src2[i];
1211 : }
1212 1088550 : for ( ; i < input_frame; i++ )
1213 : {
1214 1062000 : wnd -= wnd_diff;
1215 :
1216 1062000 : E += ( src1[i] * wnd ) * ( src2[i] * wnd );
1217 : }
1218 :
1219 26550 : *energy = *energy * ratio + ( E / (float) input_frame ) * ( 1.0f - ratio );
1220 :
1221 26550 : if ( lvl != NULL )
1222 : {
1223 17700 : lvli = log10f( E + EPSILON );
1224 17700 : lvlff = ( lvli > *lvl ) ? STEREO_DMX_EVS_LVLU_FORGETTING : STEREO_DMX_EVS_LVLD_FORGETTING;
1225 17700 : *lvl = lvlff * *lvl + ( 1.0f - lvlff ) * lvli;
1226 : }
1227 :
1228 26550 : return;
1229 : }
1230 :
1231 :
1232 : /*-------------------------------------------------------------------*
1233 : * calc_energy_sgc()
1234 : *
1235 : * calculate energy for switch gain control
1236 : *-------------------------------------------------------------------*/
1237 35400 : static void calc_energy_sgc(
1238 : const float src[], /* i : input signal */
1239 : float *energy, /* o : calculated energy */
1240 : const int16_t input_frame, /* i : input frame length */
1241 : const float ratio /* i : adapting ratio */
1242 : )
1243 : {
1244 35400 : *energy = ratio * *energy + ( 1.0f - ratio ) * sum2_f( src, input_frame );
1245 35400 : return;
1246 : }
1247 :
1248 :
1249 : /*-------------------------------------------------------------------*
1250 : * adapt_gain()
1251 : *
1252 : * adapt gain to the signal
1253 : *-------------------------------------------------------------------*/
1254 :
1255 17700 : static void adapt_gain(
1256 : const float src[], /* i : input signal */
1257 : float dst[], /* o : output signal */
1258 : const float gain, /* i : adapting gain */
1259 : const float old_gain, /* i : adapting prev gain */
1260 : const int16_t input_frame, /* i : input frame length per channel */
1261 : const float wnd[] /* i : window coef */
1262 : )
1263 : {
1264 : int16_t i, len, len2;
1265 : float gain_tmp, gain_sub;
1266 :
1267 17700 : len = input_frame >> 1;
1268 17700 : len2 = input_frame >> 2;
1269 17700 : gain_sub = gain - old_gain;
1270 :
1271 2849700 : for ( i = 0; i < len2; i++ )
1272 : {
1273 2832000 : gain_tmp = old_gain + gain_sub * wnd[i];
1274 2832000 : dst[i] = src[i] * gain_tmp;
1275 : }
1276 2849700 : for ( ; i < len; i++ )
1277 : {
1278 2832000 : gain_tmp = old_gain + gain_sub * ( 1.0f - wnd[len - i - 1] );
1279 2832000 : dst[i] = src[i] * gain_tmp;
1280 : }
1281 :
1282 5681700 : for ( ; i < input_frame; i++ )
1283 : {
1284 5664000 : dst[i] = src[i] * gain;
1285 : }
1286 :
1287 17700 : return;
1288 : }
1289 :
1290 :
1291 : /*-------------------------------------------------------------------*
1292 : * create_M_signal()
1293 : *
1294 : * create downmix signal
1295 : *-------------------------------------------------------------------*/
1296 8850 : static void create_M_signal(
1297 : const float srcL[], /* i : Lch input signal */
1298 : const float srcR[], /* i : Rch input signal */
1299 : float dmx[], /* o : output signal */
1300 : const float w_curr, /* i : adapting weight */
1301 : const int16_t input_frame, /* i : input frame length per channel */
1302 : const float wnd[], /* i : window coef */
1303 : float *w_prev, /* i/o: adapting prev weight */
1304 : float *dmx_energy, /* i/o: downmix signal energy */
1305 : float *src_energy, /* i/o: input signal energy */
1306 : STEREO_DMX_EVS_PHA_HANDLE hPHA /* i/o: correlation filter structure */
1307 : )
1308 : {
1309 : float weighted[L_FRAME48k], eps, amp_mod[CPE_CHANNELS], Lbias;
1310 :
1311 : /* Initialization */
1312 8850 : eps = 1024.0f;
1313 8850 : Lbias = ( w_prev[2] == 0 ) ? 4.0f : 0.25f;
1314 :
1315 8850 : weighted_ave( srcL, srcR, dmx, w_curr, w_prev[0], input_frame, wnd );
1316 :
1317 8850 : calc_energy( srcL, srcL, src_energy, hPHA->lvlin, input_frame, STEREO_DMX_EVS_DMX_EGY_FORGETTING );
1318 8850 : calc_energy( srcR, srcR, src_energy + 1, hPHA->lvlin + 1, input_frame, STEREO_DMX_EVS_DMX_EGY_FORGETTING );
1319 8850 : calc_energy( dmx, dmx, dmx_energy, NULL, input_frame, STEREO_DMX_EVS_DMX_EGY_FORGETTING );
1320 :
1321 8850 : if ( src_energy[0] * Lbias > src_energy[1] )
1322 : {
1323 5651 : amp_mod[0] = 1.0f - sqrtf( ( dmx_energy[0] + eps ) / ( src_energy[0] + eps ) );
1324 5651 : amp_mod[0] = max( amp_mod[0], 0.0f );
1325 5651 : amp_mod[1] = 0.0f;
1326 : }
1327 : else
1328 : {
1329 3199 : amp_mod[1] = 1.0f - sqrtf( ( dmx_energy[0] + eps ) / ( src_energy[1] + eps ) );
1330 3199 : amp_mod[1] = max( amp_mod[1], 0.0f );
1331 3199 : amp_mod[0] = 0.0f;
1332 : }
1333 :
1334 8850 : adapt_gain( srcL, weighted, amp_mod[0], w_prev[1], input_frame, wnd );
1335 8850 : v_add( dmx, weighted, dmx, input_frame );
1336 8850 : adapt_gain( srcR, weighted, amp_mod[1], w_prev[2], input_frame, wnd );
1337 8850 : v_add( dmx, weighted, dmx, input_frame );
1338 :
1339 8850 : w_prev[0] = w_curr;
1340 8850 : w_prev[1] = amp_mod[0];
1341 8850 : w_prev[2] = amp_mod[1];
1342 :
1343 8850 : return;
1344 : }
1345 :
1346 :
1347 : /*-------------------------------------------------------------------*
1348 : * apply_gain_sgc()
1349 : *
1350 : * Apply gain for switching
1351 : *-------------------------------------------------------------------*/
1352 :
1353 17700 : static void apply_gain_sgc(
1354 : float data[], /* i/o : input signal */
1355 : float *gain, /* i : gain */
1356 : float ratio, /* i : ratio */
1357 : const int16_t input_frame /* i : input frame length */
1358 : )
1359 : {
1360 : int16_t n;
1361 : float lr;
1362 :
1363 17700 : if ( *gain > STEREO_DMX_EVS_SGC_GH )
1364 : {
1365 170 : lr = 1.0f / ratio;
1366 : }
1367 17530 : else if ( *gain < STEREO_DMX_EVS_SGC_GL )
1368 : {
1369 348 : lr = ratio;
1370 : }
1371 : else
1372 : {
1373 17182 : return;
1374 : }
1375 :
1376 456838 : for ( n = 0; n < input_frame; n++ )
1377 : {
1378 456320 : data[n] *= *gain;
1379 : }
1380 :
1381 518 : *gain *= lr;
1382 : }
1383 :
1384 :
1385 : /*-------------------------------------------------------------------*
1386 : * stereo_dmx_evs_enc()
1387 : *
1388 : * Stereo downmix for EVS encoder routine
1389 : *-------------------------------------------------------------------*/
1390 :
1391 8850 : void stereo_dmx_evs_enc(
1392 : STEREO_DMX_EVS_ENC_HANDLE hStereoDmxEVS, /* i/o: Stereo downmix for EVS encoder handle */
1393 : const int32_t input_Fs, /* i : input sampling rate */
1394 : int16_t data[CPE_CHANNELS * L_FRAME48k], /* i/o: input signal */
1395 : const int16_t n_samples, /* i : number of input samples */
1396 : const bool is_binaural /* i : indication that input is binaural audio */
1397 : )
1398 : {
1399 : float dmx_weight, corr;
1400 : int16_t k, m, n, pha_len, fad_len, input_subframe, input_frame, n_fad_r, n_fad_g, m_fad_g, n_fad_cnt, sbfad_len;
1401 : float data_f[CPE_CHANNELS][L_FRAME48k];
1402 : float mem_prev[STEREO_DMX_EVS_FAD_LEN_MAX], data_mem[STEREO_DMX_EVS_DATA_LEN_MAX];
1403 : float dmx_poc_data[L_FRAME48k], dmx_pha_data[L_FRAME48k], subframe_energy[STEREO_DMX_EVS_NB_SBFRM];
1404 : float *p_data_mem, *p_prev_taps, *p_curr_taps, *p_data, *p_sub_frame;
1405 : float ftmp, *fad_g, *p_dmx_data, *p_dmx_data_fo;
1406 : bool is_transient;
1407 :
1408 : STEREO_DMX_EVS_PRC prev_prc, req_prc;
1409 : STEREO_DMX_EVS_PHA_HANDLE hPHA;
1410 :
1411 : if ( is_binaural )
1412 : {
1413 : /* use of is_binaural flag is to be considered */
1414 : }
1415 :
1416 8850 : input_frame = (int16_t) ( input_Fs / FRAMES_PER_SEC );
1417 8850 : hPHA = hStereoDmxEVS->hPHA;
1418 :
1419 5672850 : for ( n = 0; n < input_frame; n++ )
1420 : {
1421 5664000 : data_f[0][n] = (float) data[2 * n];
1422 5664000 : data_f[1][n] = (float) data[2 * n + 1];
1423 : }
1424 8850 : if ( n_samples < input_frame )
1425 : {
1426 0 : set_f( data_f[0] + n_samples, 0.0f, input_frame - n_samples );
1427 0 : set_f( data_f[1] + n_samples, 0.0f, input_frame - n_samples );
1428 : }
1429 :
1430 8850 : input_subframe = n_samples / STEREO_DMX_EVS_NB_SBFRM;
1431 8850 : is_transient = false;
1432 26550 : for ( k = 0; k < CPE_CHANNELS; k++ )
1433 : {
1434 106200 : for ( m = 0; m < STEREO_DMX_EVS_NB_SBFRM; m++ )
1435 : {
1436 88500 : p_sub_frame = &( data_f[k][m * input_subframe] );
1437 88500 : subframe_energy[m] = sum2_f( p_sub_frame, input_subframe );
1438 88500 : if ( subframe_energy[m] > hPHA->crst_fctr * ( hPHA->trns_aux_energy[k] + EPSILON ) )
1439 : {
1440 323 : is_transient = true;
1441 : }
1442 :
1443 88500 : hPHA->trns_aux_energy[k] = STEREO_DMX_EVS_TRNS_EGY_FORGETTING * hPHA->trns_aux_energy[k] + ( 1.0f - STEREO_DMX_EVS_TRNS_EGY_FORGETTING ) * subframe_energy[m];
1444 : }
1445 :
1446 88500 : for ( m = 1; m < STEREO_DMX_EVS_NB_SBFRM; m++ )
1447 : {
1448 70800 : if ( subframe_energy[m] / ( subframe_energy[m - 1] + EPSILON ) > STEREO_DMX_EVS_TRNS_DTC_INST )
1449 : {
1450 34 : is_transient = true;
1451 : }
1452 : }
1453 : }
1454 :
1455 8850 : estimate_itd( &corr, hStereoDmxEVS->hPOC, hPHA, data_f[0], data_f[1], &hStereoDmxEVS->itd, input_frame );
1456 :
1457 : /* poc */
1458 :
1459 8850 : if ( hStereoDmxEVS->itd )
1460 : {
1461 3956 : dmx_weight = ( ( hStereoDmxEVS->itd > 0 ) ? ( -1 ) : 1 ) * 0.5f * corr + 0.5f;
1462 : }
1463 : else
1464 : {
1465 4894 : dmx_weight = 0.5f;
1466 : }
1467 :
1468 8850 : hPHA->phitd = hStereoDmxEVS->itd * PI2 / input_frame;
1469 :
1470 8850 : create_M_signal( data_f[0], data_f[1], dmx_poc_data, dmx_weight, input_frame, hStereoDmxEVS->s_wnd,
1471 8850 : hStereoDmxEVS->dmx_weight, hStereoDmxEVS->pre_dmx_energy, hStereoDmxEVS->aux_dmx_energy, hPHA );
1472 :
1473 : /* pha */
1474 :
1475 8850 : pha_len = hPHA->pha_len;
1476 8850 : fad_len = hPHA->fad_len;
1477 8850 : fad_g = hPHA->fad_g;
1478 :
1479 8850 : set_zero( dmx_pha_data, n_samples );
1480 8850 : set_zero( mem_prev, fad_len );
1481 :
1482 26550 : for ( k = 0; k < CPE_CHANNELS; k++ )
1483 : {
1484 17700 : p_data = data_f[k];
1485 17700 : mvr2r( hPHA->data_mem[k], data_mem, pha_len );
1486 17700 : mvr2r( &( p_data[n_samples - pha_len] ), hPHA->data_mem[k], pha_len );
1487 17700 : p_data_mem = &( data_mem[pha_len] );
1488 17700 : mvr2r( p_data, p_data_mem, n_samples );
1489 :
1490 17700 : p_prev_taps = hPHA->p_prev_taps[k];
1491 17700 : if ( p_prev_taps )
1492 : {
1493 5588229 : for ( n = 0; n < fad_len; n++ )
1494 : {
1495 250624320 : for ( ftmp = 0, m = 0; m < pha_len; m++ )
1496 : {
1497 245053440 : ftmp += p_data_mem[n - m] * p_prev_taps[m];
1498 : }
1499 5570880 : mem_prev[n] += ftmp * INV_SQRT_2;
1500 : }
1501 : }
1502 : else
1503 : {
1504 93471 : for ( n = 0; n < fad_len; n++ )
1505 : {
1506 93120 : mem_prev[n] += p_data[n] * INV_SQRT_2;
1507 : }
1508 : }
1509 :
1510 17700 : p_curr_taps = hPHA->p_curr_taps[k];
1511 17700 : if ( p_curr_taps )
1512 : {
1513 11283503 : for ( n = 0; n < n_samples; n++ )
1514 : {
1515 506410880 : for ( ftmp = 0, m = 0; m < pha_len; m++ )
1516 : {
1517 495144960 : ftmp += p_data_mem[n - m] * p_curr_taps[m];
1518 : }
1519 11265920 : dmx_pha_data[n] += ftmp * INV_SQRT_2;
1520 : }
1521 : }
1522 : else
1523 : {
1524 62197 : for ( n = 0; n < n_samples; n++ )
1525 : {
1526 62080 : dmx_pha_data[n] += p_data[n] * INV_SQRT_2;
1527 : }
1528 : }
1529 : }
1530 :
1531 2840850 : for ( n = 0, m = ( fad_len - 1 ); n < fad_len; n++, m-- )
1532 : {
1533 2832000 : dmx_pha_data[n] *= fad_g[n];
1534 2832000 : dmx_pha_data[n] += ( mem_prev[n] ) * fad_g[m];
1535 : }
1536 :
1537 : /* prc switch */
1538 :
1539 8850 : prev_prc = hPHA->curr_prc;
1540 8850 : if ( abs( (int16_t) hStereoDmxEVS->itd ) > hPHA->prc_thres )
1541 : {
1542 725 : req_prc = STEREO_DMX_EVS_PRC_POC;
1543 725 : if ( ( fabs( hPHA->lvlin[0] - hPHA->lvlin[1] ) < STEREO_DMX_EVS_ICLD_THRESH ) && ( hPHA->iccres_s < STEREO_DMX_EVS_ICCRES_THRESH ) && ( ( ( dmx_weight + hStereoDmxEVS->dmx_weight[1] ) > STEREO_DMX_EVS_DICLD_THRESH * ( 1 - dmx_weight + hStereoDmxEVS->dmx_weight[2] ) ) || ( ( 1 - dmx_weight + hStereoDmxEVS->dmx_weight[2] ) > STEREO_DMX_EVS_DICLD_THRESH * ( dmx_weight + hStereoDmxEVS->dmx_weight[1] ) ) ) )
1544 : {
1545 0 : req_prc = STEREO_DMX_EVS_PRC_PHA;
1546 : }
1547 : }
1548 : else
1549 : {
1550 8125 : req_prc = STEREO_DMX_EVS_PRC_PHA;
1551 : }
1552 :
1553 : // Set mode with hysteresis
1554 8850 : if ( hPHA->curr_prc != req_prc )
1555 : {
1556 7081 : if ( hPHA->prev_prc == req_prc )
1557 : {
1558 6948 : hPHA->prc_hys_cnt += 1;
1559 : }
1560 : else
1561 : {
1562 133 : hPHA->prc_hys_cnt = 0;
1563 : }
1564 :
1565 7081 : if ( hPHA->prc_hys_cnt >= STEREO_DMX_EVS_SWTCH_PRC_HYS_THRES )
1566 : {
1567 6948 : hPHA->curr_prc = req_prc;
1568 : }
1569 : }
1570 8850 : hPHA->prev_prc = req_prc;
1571 :
1572 8850 : if ( is_transient || ( hStereoDmxEVS->aux_dmx_energy[0] > STEREO_DMX_EVS_ILDS_EGY * hStereoDmxEVS->aux_dmx_energy[1] ) || ( hStereoDmxEVS->aux_dmx_energy[1] > STEREO_DMX_EVS_ILDS_EGY * hStereoDmxEVS->aux_dmx_energy[0] ) || ( hPHA->force_poc ) )
1573 : {
1574 7530 : hPHA->curr_prc = STEREO_DMX_EVS_PRC_POC;
1575 7530 : hPHA->prc_hys_cnt = 0;
1576 : }
1577 :
1578 8850 : calc_energy_sgc( dmx_poc_data, &( hPHA->dmx_poc_ener ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1579 8850 : calc_energy_sgc( dmx_pha_data, &( hPHA->dmx_pha_ener ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1580 :
1581 8850 : if ( ( prev_prc != hPHA->curr_prc ) && !is_transient && !( ( hPHA->dmx_pha_ener < hPHA->low_egy_thres_sgc ) && ( hPHA->dmx_poc_ener < hPHA->low_egy_thres_sgc ) ) )
1582 : {
1583 18 : if ( hPHA->curr_prc == STEREO_DMX_EVS_PRC_POC )
1584 : {
1585 10 : apply_gain_sgc( dmx_pha_data, &( hPHA->dmx_pha_gain_sgc ), STEREO_DMX_EVS_SGC_GR_S, n_samples );
1586 10 : calc_energy_sgc( dmx_pha_data, &( hPHA->dmx_pha_ener_sgc ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1587 :
1588 10 : hPHA->dmx_poc_gain_sgc = sqrtf( hPHA->dmx_pha_ener_sgc / ( hPHA->dmx_poc_ener + EPSILON ) );
1589 10 : hPHA->dmx_poc_gain_sgc = min( hPHA->dmx_poc_gain_sgc, STEREO_DMX_EVS_SGC_GMAX );
1590 10 : hPHA->dmx_poc_gain_sgc = max( hPHA->dmx_poc_gain_sgc, STEREO_DMX_EVS_SGC_GMIN );
1591 :
1592 10 : apply_gain_sgc( dmx_poc_data, &( hPHA->dmx_poc_gain_sgc ), STEREO_DMX_EVS_SGC_GR_S, n_samples );
1593 10 : calc_energy_sgc( dmx_poc_data, &( hPHA->dmx_poc_ener_sgc ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1594 : }
1595 : else
1596 : {
1597 8 : apply_gain_sgc( dmx_poc_data, &( hPHA->dmx_poc_gain_sgc ), STEREO_DMX_EVS_SGC_GR_S, n_samples );
1598 8 : calc_energy_sgc( dmx_poc_data, &( hPHA->dmx_poc_ener_sgc ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1599 :
1600 8 : hPHA->dmx_pha_gain_sgc = sqrtf( hPHA->dmx_poc_ener_sgc / ( hPHA->dmx_pha_ener + EPSILON ) );
1601 8 : hPHA->dmx_pha_gain_sgc = min( hPHA->dmx_pha_gain_sgc, STEREO_DMX_EVS_SGC_GMAX );
1602 8 : hPHA->dmx_pha_gain_sgc = max( hPHA->dmx_pha_gain_sgc, STEREO_DMX_EVS_SGC_GMIN );
1603 :
1604 8 : apply_gain_sgc( dmx_pha_data, &( hPHA->dmx_pha_gain_sgc ), STEREO_DMX_EVS_SGC_GR_S, n_samples );
1605 8 : calc_energy_sgc( dmx_pha_data, &( hPHA->dmx_pha_ener_sgc ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1606 : }
1607 : }
1608 : else
1609 : {
1610 8832 : apply_gain_sgc( dmx_poc_data, &( hPHA->dmx_poc_gain_sgc ), STEREO_DMX_EVS_SGC_GR_S, n_samples );
1611 8832 : calc_energy_sgc( dmx_poc_data, &( hPHA->dmx_poc_ener_sgc ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1612 :
1613 8832 : apply_gain_sgc( dmx_pha_data, &( hPHA->dmx_pha_gain_sgc ), STEREO_DMX_EVS_SGC_GR_S, n_samples );
1614 8832 : calc_energy_sgc( dmx_pha_data, &( hPHA->dmx_pha_ener_sgc ), n_samples, STEREO_DMX_EVS_SGC_EGY_FORGETTING );
1615 : }
1616 :
1617 8850 : if ( hPHA->curr_prc == STEREO_DMX_EVS_PRC_POC )
1618 : {
1619 7786 : p_dmx_data = dmx_poc_data;
1620 7786 : p_dmx_data_fo = dmx_pha_data;
1621 : }
1622 : else
1623 : {
1624 1064 : p_dmx_data = dmx_pha_data;
1625 1064 : p_dmx_data_fo = dmx_poc_data;
1626 : }
1627 :
1628 8850 : n_fad_r = is_transient ? 1 : STEREO_DMX_EVS_FAD_R;
1629 :
1630 8850 : if ( prev_prc != hPHA->curr_prc )
1631 : {
1632 278 : if ( hPHA->n_fad_g == input_frame )
1633 : {
1634 275 : hPHA->n_fad_g = 0;
1635 275 : hPHA->n_fad_cnt = 0;
1636 : }
1637 : else
1638 : {
1639 3 : hPHA->n_fad_g = input_frame - hPHA->n_fad_g - 1;
1640 3 : hPHA->n_fad_cnt = 0;
1641 : }
1642 : }
1643 8572 : else if ( is_transient )
1644 : {
1645 199 : hPHA->n_fad_cnt = 0;
1646 : }
1647 :
1648 8850 : fad_len = min( n_samples, ( ( input_frame * n_fad_r ) - ( hPHA->n_fad_g * n_fad_r + hPHA->n_fad_cnt ) ) );
1649 :
1650 8850 : if ( fad_len != 0 )
1651 : {
1652 825 : fad_g = hPHA->fad_g_prc;
1653 825 : n_fad_g = hPHA->n_fad_g;
1654 825 : n_fad_cnt = hPHA->n_fad_cnt;
1655 825 : m_fad_g = input_frame - n_fad_g - 1;
1656 :
1657 825 : if ( n_fad_r == 1 )
1658 : {
1659 3 : n_fad_cnt = 0;
1660 2563 : for ( n = 0; n < fad_len; n++ )
1661 : {
1662 2560 : p_dmx_data[n] *= fad_g[n_fad_g++];
1663 2560 : p_dmx_data[n] += fad_g[m_fad_g--] * p_dmx_data_fo[n];
1664 : }
1665 : }
1666 : else
1667 : {
1668 822 : n = 0;
1669 822 : sbfad_len = 0;
1670 822 : if ( n_fad_cnt != 0 )
1671 : {
1672 409 : sbfad_len = min( fad_len, n_fad_r - n_fad_cnt );
1673 1023 : for ( ; n < sbfad_len; n++ )
1674 : {
1675 614 : p_dmx_data[n] *= fad_g[n_fad_g];
1676 614 : p_dmx_data[n] += fad_g[m_fad_g] * p_dmx_data_fo[n];
1677 : }
1678 409 : n_fad_cnt = 0;
1679 409 : n_fad_g++;
1680 409 : m_fad_g--;
1681 : }
1682 :
1683 822 : sbfad_len = (int16_t) ( ( fad_len - sbfad_len ) / n_fad_r );
1684 158708 : for ( k = 0; k < sbfad_len; k++ )
1685 : {
1686 631544 : for ( m = 0; m < n_fad_r; m++ )
1687 : {
1688 473658 : p_dmx_data[n] *= fad_g[n_fad_g];
1689 473658 : p_dmx_data[n] += fad_g[m_fad_g] * p_dmx_data_fo[n];
1690 473658 : n++;
1691 : }
1692 157886 : n_fad_g++;
1693 157886 : m_fad_g--;
1694 : }
1695 :
1696 1437 : for ( ; n < fad_len; n++ )
1697 : {
1698 615 : p_dmx_data[n] *= fad_g[n_fad_g];
1699 615 : p_dmx_data[n] += fad_g[m_fad_g] * p_dmx_data_fo[n];
1700 615 : if ( ++n_fad_cnt >= n_fad_r )
1701 : {
1702 0 : n_fad_cnt = 0;
1703 0 : n_fad_g++;
1704 0 : m_fad_g--;
1705 : }
1706 : }
1707 : }
1708 :
1709 825 : hPHA->n_fad_g = n_fad_g;
1710 825 : hPHA->n_fad_cnt = n_fad_cnt;
1711 : }
1712 :
1713 8850 : mvr2s( p_dmx_data, data, n_samples );
1714 :
1715 8850 : return;
1716 : }
1717 :
1718 :
1719 : /*-------------------------------------------------------------------*
1720 : * stereo_dmx_evs_init_encoder()
1721 : *
1722 : * open and initialize stereo downmix for EVS encoder
1723 : *-------------------------------------------------------------------*/
1724 :
1725 117 : ivas_error stereo_dmx_evs_init_encoder(
1726 : STEREO_DMX_EVS_ENC_HANDLE *hStereoDmxEVS_out, /* o : Stereo downmix for EVS encoder handle */
1727 : const int32_t input_Fs /* i : input sampling rate */
1728 : )
1729 : {
1730 : STEREO_DMX_EVS_ENC_HANDLE hStereoDmxEVS;
1731 : int16_t n, input_frame;
1732 :
1733 : int16_t m, len, pha_len, fad_len, fad_len2, trans_len, itrh, rfft_ipd_coef_step, n0, input_frame_pha;
1734 : float *win, *fad_g, fad_r, tmp_r, a_step, *ipd_ff;
1735 : const float *p_ipd_w;
1736 :
1737 117 : input_frame = (int16_t) ( input_Fs / FRAMES_PER_SEC );
1738 :
1739 117 : hStereoDmxEVS = NULL;
1740 117 : if ( ( hStereoDmxEVS = (STEREO_DMX_EVS_ENC_HANDLE) malloc( sizeof( STEREO_DMX_EVS_ENC_DATA ) ) ) == NULL )
1741 : {
1742 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for STEREO_DMX_EVS_ENC_DATA\n" ) );
1743 : }
1744 :
1745 117 : hStereoDmxEVS->itd = 0.0f;
1746 117 : hStereoDmxEVS->pre_dmx_energy[0] = 0.0f;
1747 351 : for ( n = 0; n < CPE_CHANNELS; n++ )
1748 : {
1749 234 : hStereoDmxEVS->aux_dmx_energy[n] = 0.0f;
1750 : }
1751 :
1752 117 : hStereoDmxEVS->dmx_weight[0] = 0.5f;
1753 117 : hStereoDmxEVS->dmx_weight[1] = 0.0f;
1754 117 : hStereoDmxEVS->dmx_weight[2] = 0.0f;
1755 :
1756 117 : if ( input_frame == L_FRAME16k )
1757 : {
1758 60 : hStereoDmxEVS->s_wnd = Stereo_dmx_s_wnd_coef_16k;
1759 : }
1760 57 : else if ( input_frame == L_FRAME32k )
1761 : {
1762 37 : hStereoDmxEVS->s_wnd = Stereo_dmx_s_wnd_coef_32k;
1763 : }
1764 20 : else if ( input_frame == L_FRAME48k )
1765 : {
1766 20 : hStereoDmxEVS->s_wnd = Stereo_dmx_s_wnd_coef_48k;
1767 : }
1768 : else
1769 : {
1770 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "invalid frame length\n" );
1771 : }
1772 :
1773 117 : hStereoDmxEVS->hPOC = NULL;
1774 117 : if ( ( hStereoDmxEVS->hPOC = (STEREO_DMX_EVS_POC_HANDLE) malloc( sizeof( STEREO_DMX_EVS_POC_DATA ) ) ) == NULL )
1775 : {
1776 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for STEREO_DMX_EVS_POC_DATA\n" ) );
1777 : }
1778 :
1779 117 : hStereoDmxEVS->hPOC->shift_limit = NS2SA( input_Fs, STEREO_DMX_EVS_SHIFT_LIMIT );
1780 :
1781 351 : for ( n = 0; n < CPE_CHANNELS; n++ )
1782 : {
1783 234 : hStereoDmxEVS->hPOC->peakQ[n] = 0.0f;
1784 234 : hStereoDmxEVS->hPOC->peak_width[n] = (float) hStereoDmxEVS->hPOC->shift_limit / 2;
1785 234 : hStereoDmxEVS->hPOC->ispeak[n] = 0;
1786 234 : hStereoDmxEVS->hPOC->itdLR[n] = 0;
1787 : }
1788 117 : set_f( hStereoDmxEVS->hPOC->P, 0.0f, L_FRAME48k );
1789 :
1790 117 : if ( input_frame == L_FRAME16k )
1791 : {
1792 60 : hStereoDmxEVS->hPOC->wnd = Stereo_dmx_wnd_coef_48k;
1793 : }
1794 57 : else if ( input_frame == L_FRAME32k )
1795 : {
1796 37 : hStereoDmxEVS->hPOC->wnd = Stereo_dmx_wnd_coef_32k;
1797 : }
1798 20 : else if ( input_frame == L_FRAME48k )
1799 : {
1800 20 : hStereoDmxEVS->hPOC->wnd = Stereo_dmx_wnd_coef_48k;
1801 : }
1802 : else
1803 : {
1804 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "invalid frame length\n" );
1805 : }
1806 117 : hStereoDmxEVS->hPOC->eps = 2.0f * EVS_PI / ( (float) input_frame );
1807 :
1808 117 : if ( input_frame == L_FRAME16k )
1809 : {
1810 60 : hStereoDmxEVS->hPOC->sin = dft_trigo_32k;
1811 : }
1812 57 : else if ( input_frame == L_FRAME32k )
1813 : {
1814 37 : hStereoDmxEVS->hPOC->sin = dft_trigo_32k;
1815 : }
1816 20 : else if ( input_frame == L_FRAME48k )
1817 : {
1818 20 : hStereoDmxEVS->hPOC->sin = dft_trigo_48k;
1819 : }
1820 : else
1821 : {
1822 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "invalid frame length\n" );
1823 : }
1824 :
1825 117 : hStereoDmxEVS->hPOC->confidence = 0.0f;
1826 :
1827 117 : hStereoDmxEVS->hPHA = NULL;
1828 117 : if ( ( hStereoDmxEVS->hPHA = (STEREO_DMX_EVS_PHA_HANDLE) malloc( sizeof( STEREO_DMX_EVS_PHA_DATA ) ) ) == NULL )
1829 : {
1830 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for STEREO_DMX_EVS_CORFILT_DATA\n" ) );
1831 : }
1832 :
1833 351 : for ( n = 0; n < CPE_CHANNELS; n++ )
1834 : {
1835 234 : hStereoDmxEVS->hPHA->p_curr_taps[n] = NULL;
1836 234 : hStereoDmxEVS->hPHA->p_prev_taps[n] = NULL;
1837 :
1838 234 : set_zero( hStereoDmxEVS->hPHA->data_mem[n], STEREO_DMX_EVS_PHA_LEN_MAX );
1839 234 : set_zero( hStereoDmxEVS->hPHA->curr_taps[n], STEREO_DMX_EVS_PHA_LEN_MAX );
1840 : }
1841 :
1842 117 : if ( input_Fs == 16000 )
1843 : {
1844 60 : len = STEREO_DMX_EVS_PHA_LEN_16;
1845 60 : hStereoDmxEVS->hPHA->fad_len = STEREO_DMX_EVS_FAD_LEN_16;
1846 60 : hStereoDmxEVS->hPHA->prc_thres = STEREO_DMX_EVS_SWTCH_PRC_THRES_16;
1847 60 : hStereoDmxEVS->hPHA->crst_fctr = STEREO_DMX_EVS_CRST_FCTR_16;
1848 60 : hStereoDmxEVS->hPHA->low_egy_thres_sgc = STEREO_DMX_EVS_SGC_LEGY_THRES_16;
1849 : }
1850 57 : else if ( input_Fs == 32000 )
1851 : {
1852 37 : len = STEREO_DMX_EVS_PHA_LEN_32;
1853 37 : hStereoDmxEVS->hPHA->fad_len = STEREO_DMX_EVS_FAD_LEN_32;
1854 37 : hStereoDmxEVS->hPHA->prc_thres = STEREO_DMX_EVS_SWTCH_PRC_THRES_32;
1855 37 : hStereoDmxEVS->hPHA->crst_fctr = STEREO_DMX_EVS_CRST_FCTR_32;
1856 37 : hStereoDmxEVS->hPHA->low_egy_thres_sgc = STEREO_DMX_EVS_SGC_LEGY_THRES_32;
1857 : }
1858 20 : else if ( input_Fs == 48000 )
1859 : {
1860 20 : len = STEREO_DMX_EVS_PHA_LEN_48;
1861 20 : hStereoDmxEVS->hPHA->fad_len = STEREO_DMX_EVS_FAD_LEN_48;
1862 20 : hStereoDmxEVS->hPHA->prc_thres = STEREO_DMX_EVS_SWTCH_PRC_THRES_48;
1863 20 : hStereoDmxEVS->hPHA->crst_fctr = STEREO_DMX_EVS_CRST_FCTR_48;
1864 20 : hStereoDmxEVS->hPHA->low_egy_thres_sgc = STEREO_DMX_EVS_SGC_LEGY_THRES_48;
1865 : }
1866 : else
1867 : {
1868 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "invalid sampling frequency\n" );
1869 : }
1870 :
1871 117 : hStereoDmxEVS->hPHA->pha_len = len / 2;
1872 117 : hStereoDmxEVS->hPHA->isd_rate_s = 0.0f;
1873 117 : hStereoDmxEVS->hPHA->iccr_s = 0.0f;
1874 117 : hStereoDmxEVS->hPHA->iccres_s = 0.0f;
1875 117 : hStereoDmxEVS->hPHA->phitd = 0.0f;
1876 351 : for ( n = 0; n < CPE_CHANNELS; n++ )
1877 : {
1878 234 : hStereoDmxEVS->hPHA->lvlin[n] = 0.0f;
1879 : }
1880 :
1881 117 : pha_len = hStereoDmxEVS->hPHA->pha_len;
1882 117 : fad_len = hStereoDmxEVS->hPHA->fad_len;
1883 :
1884 117 : trans_len = (int16_t) ( (float) pha_len / 20.0f );
1885 117 : set_f( hStereoDmxEVS->hPHA->win, STEREO_DMX_EVS_PHA_WND_C, pha_len - trans_len );
1886 117 : hStereoDmxEVS->hPHA->win[0] = 1.0f;
1887 117 : tmp_r = 1.0f / ( ( trans_len * 2 ) + 1 );
1888 117 : win = &( hStereoDmxEVS->hPHA->win[pha_len - trans_len] );
1889 291 : for ( n = 0; n < trans_len; n++ )
1890 : {
1891 174 : win[n] = ( 0.5f * ( 1.0f + cosf( ( PI2 * ( n + 1 ) ) * tmp_r ) ) ) * STEREO_DMX_EVS_PHA_WND_C;
1892 : }
1893 :
1894 117 : fad_g = hStereoDmxEVS->hPHA->fad_g;
1895 117 : fad_r = 1.0f / (float) ( fad_len + 1 );
1896 117 : fad_len2 = fad_len / 2;
1897 15637 : for ( n = 0, m = ( fad_len - 1 ); n < fad_len2; n++, m-- )
1898 : {
1899 15520 : fad_g[n] = (float) ( n + 1 ) * fad_r;
1900 15520 : fad_g[m] = 1.0f - fad_g[n];
1901 : }
1902 :
1903 117 : hStereoDmxEVS->hPHA->curr_pha = STEREO_DMX_EVS_PHA_IPD;
1904 117 : hStereoDmxEVS->hPHA->prev_pha = STEREO_DMX_EVS_PHA_IPD;
1905 117 : hStereoDmxEVS->hPHA->pha_hys_cnt = 0;
1906 :
1907 :
1908 117 : hStereoDmxEVS->hPHA->pha_ipd_chan_cnt = 0;
1909 117 : hStereoDmxEVS->hPHA->pha_ipd_chan_thresh = 10;
1910 117 : hStereoDmxEVS->hPHA->pha_ipd_ild_thresh = STEREO_DMX_EVS_IPD_ILD_THRES;
1911 117 : hStereoDmxEVS->hPHA->pha_ipd_chan2rephase = 1;
1912 117 : hStereoDmxEVS->hPHA->pha_ipd_previouschan2rephase = 1;
1913 117 : hStereoDmxEVS->hPHA->pha_ipd_chanswitch = 0;
1914 117 : hStereoDmxEVS->hPHA->pha_ipd_chanswitch_allowed = 0;
1915 117 : hStereoDmxEVS->hPHA->pha_ipd_sf_Threshold = STEREO_DMX_EVS_IPD_SF_THRES;
1916 :
1917 117 : hStereoDmxEVS->hPHA->proc_pha = STEREO_DMX_EVS_PHA_IPD;
1918 117 : hStereoDmxEVS->hPHA->force_poc = FALSE;
1919 :
1920 : /* Compute the forgetting factor */
1921 117 : itrh = (int16_t) ( ( STEREO_DMX_EVS_IFF_FREQ * input_frame ) / ( input_Fs * STEREO_DMX_EVS_SUBBAND_SIZE ) );
1922 117 : n0 = L_FRAME16k / ( 2 * STEREO_DMX_EVS_SUBBAND_SIZE );
1923 117 : a_step = ( STEREO_DMX_EVS_IFF_AMIN - STEREO_DMX_EVS_IFF_AMAX ) / ( n0 + 1 - itrh );
1924 117 : ipd_ff = hStereoDmxEVS->hPHA->ipd_ff;
1925 3627 : for ( n = 0; n < itrh; n++ )
1926 : {
1927 3510 : ipd_ff[n] = STEREO_DMX_EVS_IFF_AMAX;
1928 : }
1929 6084 : for ( ; n < ( n0 + 1 ); n++ ) /* 8kHz */
1930 : {
1931 5967 : ipd_ff[n] = STEREO_DMX_EVS_IFF_AMAX + ( n - itrh ) * a_step;
1932 : }
1933 18720 : for ( ; n < STEREO_DMX_EVS_NB_SUBBAND_MAX; n++ )
1934 : {
1935 18603 : ipd_ff[n] = STEREO_DMX_EVS_IFF_AMIN;
1936 : }
1937 117 : set_f( hStereoDmxEVS->hPHA->Pr, 1.0, STEREO_DMX_EVS_NB_SUBBAND_MAX );
1938 117 : set_zero( hStereoDmxEVS->hPHA->Pi, STEREO_DMX_EVS_NB_SUBBAND_MAX );
1939 :
1940 117 : n0 = input_frame / ( 4 * STEREO_DMX_EVS_SUBBAND_SIZE );
1941 117 : input_frame_pha = input_frame / ( 2 * STEREO_DMX_EVS_SUBBAND_SIZE );
1942 :
1943 117 : if ( input_frame == L_FRAME16k )
1944 : {
1945 60 : p_ipd_w = dft_trigo_32k;
1946 60 : rfft_ipd_coef_step = 4;
1947 : }
1948 57 : else if ( input_frame == L_FRAME32k )
1949 : {
1950 37 : p_ipd_w = dft_trigo_32k;
1951 37 : rfft_ipd_coef_step = 2;
1952 : }
1953 20 : else if ( input_frame == L_FRAME48k )
1954 : {
1955 20 : p_ipd_w = dft_trigo_48k;
1956 20 : rfft_ipd_coef_step = 2;
1957 : }
1958 : else
1959 : {
1960 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "invalid sampling frequency\n" );
1961 : }
1962 :
1963 117 : win = hStereoDmxEVS->hPHA->rfft_ipd_coef;
1964 117 : len = rfft_ipd_coef_step * STEREO_DMX_EVS_SUBBAND_SIZE;
1965 7877 : for ( n = 0; n < n0; n++ )
1966 : {
1967 7760 : win[n] = p_ipd_w[n * len];
1968 7760 : win[input_frame_pha - n] = p_ipd_w[n * len];
1969 : }
1970 117 : win[n0] = p_ipd_w[n0 * len];
1971 :
1972 117 : hStereoDmxEVS->hPHA->curr_prc = STEREO_DMX_EVS_PRC_POC;
1973 117 : hStereoDmxEVS->hPHA->prev_prc = STEREO_DMX_EVS_PRC_POC;
1974 117 : hStereoDmxEVS->hPHA->prc_hys_cnt = 0;
1975 :
1976 117 : fad_len = input_frame;
1977 :
1978 117 : fad_g = hStereoDmxEVS->hPHA->fad_g_prc;
1979 117 : fad_r = 1.0f / (float) ( fad_len + 1 );
1980 117 : fad_len2 = fad_len / 2;
1981 31157 : for ( n = 0, m = ( fad_len - 1 ); n < fad_len2; n++, m-- )
1982 : {
1983 31040 : fad_g[n] = (float) ( n + 1 ) * fad_r;
1984 31040 : fad_g[m] = 1.0f - fad_g[n];
1985 : }
1986 :
1987 351 : for ( n = 0; n < CPE_CHANNELS; n++ )
1988 : {
1989 234 : hStereoDmxEVS->hPHA->trns_aux_energy[n] = 0.0f;
1990 : }
1991 :
1992 :
1993 117 : hStereoDmxEVS->hPHA->n_fad_g = input_frame;
1994 117 : hStereoDmxEVS->hPHA->n_fad_cnt = 0;
1995 :
1996 117 : hStereoDmxEVS->hPHA->dmx_pha_ener_sgc = 0.0f;
1997 117 : hStereoDmxEVS->hPHA->dmx_poc_ener_sgc = 0.0f;
1998 117 : hStereoDmxEVS->hPHA->dmx_pha_gain_sgc = 1.0f;
1999 117 : hStereoDmxEVS->hPHA->dmx_poc_gain_sgc = 1.0f;
2000 :
2001 117 : hStereoDmxEVS->hPHA->dmx_pha_ener = 0.0f;
2002 117 : hStereoDmxEVS->hPHA->dmx_poc_ener = 0.0f;
2003 :
2004 :
2005 117 : *hStereoDmxEVS_out = hStereoDmxEVS;
2006 :
2007 117 : return IVAS_ERR_OK;
2008 : }
2009 :
2010 :
2011 : /*-------------------------------------------------------------------*
2012 : * stereo_dmx_evs_close_encoder()
2013 : *
2014 : * close stereo downmix for EVS encoder
2015 : *-------------------------------------------------------------------*/
2016 :
2017 5803 : void stereo_dmx_evs_close_encoder(
2018 : STEREO_DMX_EVS_ENC_HANDLE *hStereoDmxEVS /* i/o: Stereo downmix for EVS encoder handle */
2019 : )
2020 : {
2021 5803 : if ( hStereoDmxEVS == NULL || *hStereoDmxEVS == NULL )
2022 : {
2023 5686 : return;
2024 : }
2025 :
2026 117 : if ( ( *hStereoDmxEVS )->hPOC != NULL )
2027 : {
2028 117 : free( ( *hStereoDmxEVS )->hPOC );
2029 117 : ( *hStereoDmxEVS )->hPOC = NULL;
2030 : }
2031 :
2032 117 : if ( ( *hStereoDmxEVS )->hPHA != NULL )
2033 : {
2034 117 : free( ( *hStereoDmxEVS )->hPHA );
2035 117 : ( *hStereoDmxEVS )->hPHA = NULL;
2036 : }
2037 :
2038 117 : free( ( *hStereoDmxEVS ) );
2039 117 : ( *hStereoDmxEVS ) = NULL;
2040 :
2041 117 : return;
2042 : }
|
