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 "options.h"
35 : #include "prot_fx.h"
36 : #include "ivas_rom_binaural_crend_head.h"
37 : #include "ivas_prot_rend_fx.h"
38 : #include "ivas_error.h"
39 : #include "wmc_auto.h"
40 : #include "ivas_prot_fx.h"
41 :
42 : /*-----------------------------------------------------------------------*
43 : * ivas_HRTF_binary_open()
44 : *
45 : * Allocate HRTF binary handle for TD renderer
46 : *-----------------------------------------------------------------------*/
47 :
48 57 : ivas_error ivas_HRTF_binary_open_fx(
49 : TDREND_HRFILT_FiltSet_t **hHrtfTD )
50 : {
51 : /* Allocate HR filter set for headphones configuration */
52 57 : *hHrtfTD = (TDREND_HRFILT_FiltSet_t *) malloc( sizeof( TDREND_HRFILT_FiltSet_t ) );
53 57 : IF( *hHrtfTD == NULL )
54 : {
55 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF binary!" );
56 : }
57 :
58 57 : set_c( (int8_t *) ( *hHrtfTD ), 0, (int32_t) sizeof( TDREND_HRFILT_FiltSet_t ) );
59 :
60 57 : return IVAS_ERR_OK;
61 : }
62 :
63 :
64 : /*-------------------------------------------------------------------*
65 : * ivas_HRTF_binary_close()
66 : *
67 : * Close HRTF binary handle for TD renderer
68 : *-------------------------------------------------------------------*/
69 :
70 934 : void ivas_HRTF_binary_close_fx(
71 : TDREND_HRFILT_FiltSet_t **hHrtfTD )
72 : {
73 934 : test();
74 934 : IF( hHrtfTD == NULL || *hHrtfTD == NULL )
75 : {
76 877 : return;
77 : }
78 :
79 57 : free( *hHrtfTD );
80 57 : *hHrtfTD = NULL;
81 :
82 57 : return;
83 : }
84 :
85 :
86 : #ifdef FIX_CREND_SIMPLIFY_CODE
87 :
88 : /*-----------------------------------------------------------------------*
89 : * ivas_HRTF_CRend_binary_open()
90 : *
91 : * Allocate HRTF binary handle for Crend renderer
92 : *-----------------------------------------------------------------------*/
93 :
94 28 : ivas_error ivas_HRTF_CRend_binary_open_fx(
95 : HRTFS_CREND_DATA **hHrtfCrend )
96 : {
97 : ivas_error error;
98 :
99 28 : IF( ( *hHrtfCrend = (HRTFS_CREND_HANDLE) malloc( sizeof( HRTFS_CREND_DATA ) ) ) == NULL )
100 : {
101 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend HRTFS Handle\n" );
102 : }
103 :
104 28 : IF( ( error = ivas_Crend_hrtf_init_fx( *hHrtfCrend ) ) != IVAS_ERR_OK )
105 : {
106 0 : return error;
107 : }
108 :
109 28 : return IVAS_ERR_OK;
110 : }
111 :
112 :
113 : /*-----------------------------------------------------------------------*
114 : * ivas_HRTF_CRend_binary_open_buffers_int16()
115 : *
116 : * Allocate buffer with dynamic length for HRTF binary Crend handle
117 : *-----------------------------------------------------------------------*/
118 :
119 2640 : ivas_error ivas_HRTF_CRend_binary_open_buffers_int16(
120 : Word16 **buffer, /* o : buffer to allocate */
121 : const UWord32 mem_size /* i : size of buffer */
122 : )
123 : {
124 2640 : *buffer = (Word16 *) malloc( mem_size );
125 :
126 2640 : IF( *buffer == NULL )
127 : {
128 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF binary data\n" );
129 : }
130 :
131 2640 : return IVAS_ERR_OK;
132 : }
133 :
134 : #else
135 : /*-----------------------------------------------------------------------*
136 : * ivas_HRTF_CRend_binary_open()
137 : *
138 : * Allocate HRTF binary handle
139 : *-----------------------------------------------------------------------*/
140 :
141 : ivas_error ivas_HRTF_CRend_binary_open_fx(
142 : HRTFS_CREND **hSetOfHRTF )
143 : {
144 : /* Allocate HR filter set for headphones configuration */
145 : *hSetOfHRTF = (HRTFS_CREND *) malloc( sizeof( HRTFS_CREND ) );
146 : IF( *hSetOfHRTF == NULL )
147 : {
148 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for set of HRTF binary!" );
149 : }
150 :
151 : ( *hSetOfHRTF )->hHRTF_hrir_combined = NULL;
152 : ( *hSetOfHRTF )->hHRTF_hrir_hoa3 = NULL;
153 : ( *hSetOfHRTF )->hHRTF_hrir_hoa2 = NULL;
154 : ( *hSetOfHRTF )->hHRTF_hrir_foa = NULL;
155 : ( *hSetOfHRTF )->hHRTF_brir_combined = NULL;
156 :
157 : return IVAS_ERR_OK;
158 : }
159 :
160 : #endif
161 :
162 : #ifdef FIX_CREND_SIMPLIFY_CODE
163 :
164 : /*-------------------------------------------------------------------*
165 : * ivas_HRTF_CRend_binary_close()
166 : *
167 : * Close HRTF CRend binary handle for Crend renderer
168 : *-------------------------------------------------------------------*/
169 :
170 1471 : void ivas_HRTF_CRend_binary_close_fx(
171 : HRTFS_CREND_DATA **hHrtfCrend )
172 : {
173 : UWord16 i, j;
174 :
175 1471 : test();
176 1471 : IF( *hHrtfCrend == NULL || hHrtfCrend == NULL )
177 : {
178 1443 : return;
179 : }
180 :
181 476 : FOR( i = 0; i < MAX_INTERN_CHANNELS; i++ )
182 : {
183 1344 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
184 : {
185 896 : IF( ( *hHrtfCrend )->pIndex_frequency_max[i][j] != NULL )
186 : {
187 840 : free( ( *hHrtfCrend )->pIndex_frequency_max_dyn_fx[i][j] );
188 : }
189 896 : IF( ( *hHrtfCrend )->pOut_to_bin_re_fx[i][j] != NULL )
190 : {
191 840 : free( ( *hHrtfCrend )->pOut_to_bin_re_dyn_fx[i][j] );
192 : }
193 896 : IF( ( *hHrtfCrend )->pOut_to_bin_im_fx[i][j] != NULL )
194 : {
195 840 : free( ( *hHrtfCrend )->pOut_to_bin_im_dyn_fx[i][j] );
196 : }
197 : }
198 : }
199 84 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
200 : {
201 56 : IF( ( *hHrtfCrend )->pIndex_frequency_max_diffuse[j] != NULL )
202 : {
203 40 : free( ( *hHrtfCrend )->pIndex_frequency_max_diffuse_dyn_fx[j] );
204 : }
205 56 : IF( ( *hHrtfCrend )->pOut_to_bin_diffuse_re_fx[j] != NULL )
206 : {
207 40 : free( ( *hHrtfCrend )->pOut_to_bin_diffuse_re_dyn_fx[j] );
208 : }
209 56 : IF( ( *hHrtfCrend )->pOut_to_bin_diffuse_im_fx[j] != NULL )
210 : {
211 40 : free( ( *hHrtfCrend )->pOut_to_bin_diffuse_im_dyn_fx[j] );
212 : }
213 : }
214 :
215 28 : free( *hHrtfCrend );
216 28 : *hHrtfCrend = NULL;
217 :
218 28 : return;
219 : }
220 : #else
221 : /*-------------------------------------------------------------------*
222 : * ivas_HRTF_CRend_binary_close()
223 : *
224 : * Close HRTF CRend binary handle
225 : *-------------------------------------------------------------------*/
226 :
227 : void ivas_HRTF_CRend_binary_close_fx(
228 : HRTFS_CREND **hSetOfHRTF )
229 : {
230 : test();
231 : IF( hSetOfHRTF == NULL || *hSetOfHRTF == NULL )
232 : {
233 : return;
234 : }
235 :
236 : free( *hSetOfHRTF );
237 : *hSetOfHRTF = NULL;
238 :
239 : return;
240 : }
241 : #endif
242 :
243 :
244 : /*-----------------------------------------------------------------------*
245 : * ivas_HRTF_fastconv_binary_open()
246 : *
247 : * Allocate HRTF binary handle for FASTCONV renderer
248 : *-----------------------------------------------------------------------*/
249 :
250 68 : ivas_error ivas_HRTF_fastconv_binary_open_fx(
251 : HRTFS_FASTCONV **hHrtfFastConv )
252 : {
253 68 : *hHrtfFastConv = (HRTFS_FASTCONV *) malloc( sizeof( HRTFS_FASTCONV ) );
254 68 : IF( *hHrtfFastConv == NULL )
255 : {
256 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for FASTCONV HRTF tables!" );
257 : }
258 :
259 68 : ivas_init_binaural_hrtf_fx( *hHrtfFastConv );
260 :
261 68 : return IVAS_ERR_OK;
262 : }
263 :
264 :
265 : /*-----------------------------------------------------------------------*
266 : * ivas_HRTF_fastconv_binary_close()
267 : *
268 : * Close HRTF binary handle for FASTCONV renderer
269 : *-----------------------------------------------------------------------*/
270 :
271 1429 : void ivas_HRTF_fastconv_binary_close_fx(
272 : HRTFS_FASTCONV **hHrtfFastConv )
273 : {
274 1429 : test();
275 1429 : IF( hHrtfFastConv == NULL || *hHrtfFastConv == NULL )
276 : {
277 1317 : return;
278 : }
279 :
280 112 : free( *hHrtfFastConv );
281 112 : *hHrtfFastConv = NULL;
282 :
283 112 : return;
284 : }
285 :
286 :
287 : /*-----------------------------------------------------------------------*
288 : * ivas_HRTF_parambin_binary_open()
289 : *
290 : * Allocate HRTF binary handle for parametric binauralizer
291 : *-----------------------------------------------------------------------*/
292 :
293 90 : ivas_error ivas_HRTF_parambin_binary_open_fx(
294 : HRTFS_PARAMBIN **hHrtfParambin )
295 : {
296 90 : *hHrtfParambin = (HRTFS_PARAMBIN *) malloc( sizeof( HRTFS_PARAMBIN ) );
297 90 : IF( *hHrtfParambin == NULL )
298 : {
299 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for parametric binauralizer HRTF tables!" );
300 : }
301 :
302 90 : set_c( (int8_t *) ( *hHrtfParambin ), 0, (int32_t) sizeof( HRTFS_PARAMBIN ) );
303 :
304 90 : return IVAS_ERR_OK;
305 : }
306 :
307 :
308 : /*-----------------------------------------------------------------------*
309 : * ivas_HRTF_parambin_binary_close()
310 : *
311 : * Close HRTF binary handle for parametric binauralizer
312 : *-----------------------------------------------------------------------*/
313 :
314 1419 : void ivas_HRTF_parambin_binary_close_fx(
315 : HRTFS_PARAMBIN **hHrtfParambin )
316 : {
317 1419 : test();
318 1419 : IF( hHrtfParambin == NULL || *hHrtfParambin == NULL )
319 : {
320 1222 : return;
321 : }
322 :
323 197 : free( *hHrtfParambin );
324 197 : *hHrtfParambin = NULL;
325 :
326 197 : return;
327 : }
328 :
329 : /*-----------------------------------------------------------------------*
330 : * ivas_HRTF_statistics_binary_open()
331 : *
332 : * Allocate HRTF binary handle for statistics handler
333 : *-----------------------------------------------------------------------*/
334 :
335 3 : ivas_error ivas_HRTF_statistics_binary_open_fx(
336 : HRTFS_STATISTICS **hHrtfStatistics )
337 : {
338 3 : *hHrtfStatistics = (HRTFS_STATISTICS *) malloc( sizeof( HRTFS_STATISTICS ) );
339 3 : IF( *hHrtfStatistics == NULL )
340 : {
341 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for statistics HRTF tables!" );
342 : }
343 :
344 3 : return IVAS_ERR_OK;
345 : }
346 :
347 :
348 : /*-----------------------------------------------------------------------*
349 : * ivas_HRTF_statistics_close()
350 : *
351 : * Close HRTF binary handle for statistics handler
352 : *-----------------------------------------------------------------------*/
353 :
354 2597 : void ivas_HRTF_statistics_close_fx(
355 : HRTFS_STATISTICS **hHrtfStatistics )
356 : {
357 2597 : test();
358 2597 : IF( hHrtfStatistics == NULL || *hHrtfStatistics == NULL )
359 : {
360 2486 : return;
361 : }
362 :
363 111 : free( *hHrtfStatistics );
364 111 : *hHrtfStatistics = NULL;
365 :
366 111 : return;
367 : }
368 :
369 :
370 : /*-----------------------------------------------------------------------*
371 : * ivas_HRTF_statistics_init()
372 : *
373 : * Allocates HRTF statistics handle and initializes from ROM
374 : *-----------------------------------------------------------------------*/
375 :
376 111 : ivas_error ivas_HRTF_statistics_init_fx(
377 : HRTFS_STATISTICS_HANDLE *hHrtfStatistics,
378 : #ifdef FIX_CREND_SIMPLIFY_CODE
379 : const Word32 sampleRate
380 : #else
381 : Word32 sampleRate
382 : #endif
383 : )
384 : {
385 : HRTFS_STATISTICS *HrtfStatistics;
386 :
387 111 : test();
388 111 : IF( hHrtfStatistics != NULL && *hHrtfStatistics != NULL )
389 : {
390 : /* Tables already loaded from file */
391 3 : return IVAS_ERR_OK;
392 : }
393 :
394 : /* Initialise tables from ROM */
395 108 : IF( ( HrtfStatistics = (HRTFS_STATISTICS *) malloc( sizeof( HRTFS_STATISTICS ) ) ) == NULL )
396 : {
397 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for statistics HRTF tables!" );
398 : }
399 :
400 108 : HrtfStatistics->average_energy_l = NULL;
401 108 : HrtfStatistics->average_energy_r = NULL;
402 108 : HrtfStatistics->inter_aural_coherence = NULL;
403 :
404 108 : SWITCH( sampleRate )
405 : {
406 96 : case 48000:
407 96 : HrtfStatistics->average_energy_l_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC * sizeof( Word32 ) );
408 96 : IF( HrtfStatistics->average_energy_l_dyn == NULL )
409 : {
410 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
411 : }
412 96 : HrtfStatistics->average_energy_r_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC * sizeof( Word32 ) );
413 96 : IF( HrtfStatistics->average_energy_r_dyn == NULL )
414 : {
415 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
416 : }
417 96 : HrtfStatistics->inter_aural_coherence_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC * sizeof( Word32 ) );
418 96 : IF( HrtfStatistics->inter_aural_coherence_dyn == NULL )
419 : {
420 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
421 : }
422 : #ifdef USE_REVERB_16BIT_ROM
423 96 : Copy_Scale_sig_16_32_r( defaultHRIR_left_avg_power_48kHz_fx, HrtfStatistics->average_energy_l_dyn, LR_IAC_LENGTH_NR_FC, Q28 - defaultHRIR_Q_48kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
424 96 : Copy_Scale_sig_16_32_r( defaultHRIR_right_avg_power_48kHz_fx, HrtfStatistics->average_energy_r_dyn, LR_IAC_LENGTH_NR_FC, Q28 - defaultHRIR_Q_48kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
425 96 : Copy_Scale_sig_16_32_r( defaultHRIR_coherence_48kHz_fx, HrtfStatistics->inter_aural_coherence_dyn, LR_IAC_LENGTH_NR_FC, Q26 - defaultHRIR_Q_48kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
426 : #else
427 : floatToFixed_arr32( defaultHRIR_left_avg_power_48kHz_fx, HrtfStatistics->average_energy_l_dyn, Q28, LR_IAC_LENGTH_NR_FC ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
428 : floatToFixed_arr32( defaultHRIR_right_avg_power_48kHz_fx, HrtfStatistics->average_energy_r_dyn, Q28, LR_IAC_LENGTH_NR_FC ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
429 : floatToFixed_arr32( defaultHRIR_coherence_48kHz_fx, HrtfStatistics->inter_aural_coherence_dyn, Q26, LR_IAC_LENGTH_NR_FC ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
430 : #endif
431 96 : HrtfStatistics->average_energy_l = (const Word32 *) HrtfStatistics->average_energy_l_dyn;
432 96 : HrtfStatistics->average_energy_r = (const Word32 *) HrtfStatistics->average_energy_r_dyn;
433 96 : HrtfStatistics->inter_aural_coherence = (const Word32 *) HrtfStatistics->inter_aural_coherence_dyn;
434 96 : BREAK;
435 8 : case 32000:
436 8 : HrtfStatistics->average_energy_l_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC * sizeof( Word32 ) );
437 8 : IF( HrtfStatistics->average_energy_l_dyn == NULL )
438 : {
439 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
440 : }
441 8 : HrtfStatistics->average_energy_r_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC * sizeof( Word32 ) );
442 8 : IF( HrtfStatistics->average_energy_r_dyn == NULL )
443 : {
444 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
445 : }
446 8 : HrtfStatistics->inter_aural_coherence_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC * sizeof( Word32 ) );
447 8 : IF( HrtfStatistics->inter_aural_coherence_dyn == NULL )
448 : {
449 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
450 : }
451 : #ifdef USE_REVERB_16BIT_ROM
452 8 : Copy_Scale_sig_16_32_r( defaultHRIR_left_avg_power_32kHz_fx, HrtfStatistics->average_energy_l_dyn, LR_IAC_LENGTH_NR_FC, Q28 - defaultHRIR_Q_32kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
453 8 : Copy_Scale_sig_16_32_r( defaultHRIR_right_avg_power_32kHz_fx, HrtfStatistics->average_energy_r_dyn, LR_IAC_LENGTH_NR_FC, Q28 - defaultHRIR_Q_32kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
454 8 : Copy_Scale_sig_16_32_r( defaultHRIR_coherence_32kHz_fx, HrtfStatistics->inter_aural_coherence_dyn, LR_IAC_LENGTH_NR_FC, Q26 - defaultHRIR_Q_32kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
455 : #else
456 : floatToFixed_arr32( defaultHRIR_left_avg_power_32kHz_fx, HrtfStatistics->average_energy_l_dyn, Q28, LR_IAC_LENGTH_NR_FC ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
457 : floatToFixed_arr32( defaultHRIR_right_avg_power_32kHz_fx, HrtfStatistics->average_energy_r_dyn, Q28, LR_IAC_LENGTH_NR_FC ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
458 : floatToFixed_arr32( defaultHRIR_coherence_32kHz_fx, HrtfStatistics->inter_aural_coherence_dyn, Q26, LR_IAC_LENGTH_NR_FC ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
459 : #endif
460 8 : HrtfStatistics->average_energy_l = (const Word32 *) HrtfStatistics->average_energy_l_dyn;
461 8 : HrtfStatistics->average_energy_r = (const Word32 *) HrtfStatistics->average_energy_r_dyn;
462 8 : HrtfStatistics->inter_aural_coherence = (const Word32 *) HrtfStatistics->inter_aural_coherence_dyn;
463 8 : BREAK;
464 4 : case 16000:
465 4 : HrtfStatistics->average_energy_l_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC_16KHZ * sizeof( Word32 ) );
466 4 : IF( HrtfStatistics->average_energy_l_dyn == NULL )
467 : {
468 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
469 : }
470 4 : HrtfStatistics->average_energy_r_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC_16KHZ * sizeof( Word32 ) );
471 4 : IF( HrtfStatistics->average_energy_r_dyn == NULL )
472 : {
473 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
474 : }
475 4 : HrtfStatistics->inter_aural_coherence_dyn = (Word32 *) malloc( LR_IAC_LENGTH_NR_FC_16KHZ * sizeof( Word32 ) );
476 4 : IF( HrtfStatistics->inter_aural_coherence_dyn == NULL )
477 : {
478 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
479 : }
480 : #ifdef USE_REVERB_16BIT_ROM
481 4 : Copy_Scale_sig_16_32_r( defaultHRIR_left_avg_power_16kHz_fx, HrtfStatistics->average_energy_l_dyn, LR_IAC_LENGTH_NR_FC_16KHZ, Q28 - defaultHRIR_Q_16kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
482 4 : Copy_Scale_sig_16_32_r( defaultHRIR_right_avg_power_16kHz_fx, HrtfStatistics->average_energy_r_dyn, LR_IAC_LENGTH_NR_FC_16KHZ, Q28 - defaultHRIR_Q_16kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
483 4 : Copy_Scale_sig_16_32_r( defaultHRIR_coherence_16kHz_fx, HrtfStatistics->inter_aural_coherence_dyn, LR_IAC_LENGTH_NR_FC_16KHZ, Q26 - defaultHRIR_Q_16kHz_fx ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
484 : #else
485 : floatToFixed_arr32( defaultHRIR_left_avg_power_16kHz_fx, HrtfStatistics->average_energy_l_dyn, Q28, LR_IAC_LENGTH_NR_FC_16KHZ ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
486 : floatToFixed_arr32( defaultHRIR_right_avg_power_16kHz_fx, HrtfStatistics->average_energy_r_dyn, Q28, LR_IAC_LENGTH_NR_FC_16KHZ ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
487 : floatToFixed_arr32( defaultHRIR_coherence_16kHz_fx, HrtfStatistics->inter_aural_coherence_dyn, Q26, LR_IAC_LENGTH_NR_FC_16KHZ ); /* tables from which lr_energy_and_iac is updated has Q27 for i=2 */
488 : #endif
489 4 : HrtfStatistics->average_energy_l = (const Word32 *) HrtfStatistics->average_energy_l_dyn;
490 4 : HrtfStatistics->average_energy_r = (const Word32 *) HrtfStatistics->average_energy_r_dyn;
491 4 : HrtfStatistics->inter_aural_coherence = (const Word32 *) HrtfStatistics->inter_aural_coherence_dyn;
492 4 : BREAK;
493 : }
494 108 : HrtfStatistics->fromROM = TRUE;
495 : #ifdef FIX_1990_SANITIZER_IN_REVERB_LOAD
496 108 : HrtfStatistics->fromROM = FALSE; // TODO: temporary hack until HRTF statistics ROM tables are converted from Word16 to Word32
497 : #endif
498 :
499 108 : *hHrtfStatistics = HrtfStatistics;
500 :
501 108 : return IVAS_ERR_OK;
502 : }
|
